README

GoCV

GoCV

Go Reference CircleCI Build status AppVeyor Build status codecov Go Report Card License

The GoCV package provides Go language bindings for the OpenCV 4 computer vision library.

The GoCV package supports the latest releases of Go and OpenCV (v4.5.2) on Linux, macOS, and Windows. We intend to make the Go language a "first-class" client compatible with the latest developments in the OpenCV ecosystem.

GoCV supports CUDA for hardware acceleration using Nvidia GPUs. Check out the CUDA README for more info on how to use GoCV with OpenCV/CUDA.

GoCV also supports Intel OpenVINO. Check out the OpenVINO README for more info on how to use GoCV with the Intel OpenVINO toolkit.

How to use

Hello, video

This example opens a video capture device using device "0", reads frames, and shows the video in a GUI window:

package main

import (
	"gocv.io/x/gocv"
)

func main() {
	webcam, _ := gocv.OpenVideoCapture(0)
	window := gocv.NewWindow("Hello")
	img := gocv.NewMat()

	for {
		webcam.Read(&img)
		window.IMShow(img)
		window.WaitKey(1)
	}
}
Face detect

GoCV

This is a more complete example that opens a video capture device using device "0". It also uses the CascadeClassifier class to load an external data file containing the classifier data. The program grabs each frame from the video, then uses the classifier to detect faces. If any faces are found, it draws a green rectangle around each one, then displays the video in an output window:

package main

import (
	"fmt"
	"image/color"

	"gocv.io/x/gocv"
)

func main() {
    // set to use a video capture device 0
    deviceID := 0

	// open webcam
	webcam, err := gocv.OpenVideoCapture(deviceID)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer webcam.Close()

	// open display window
	window := gocv.NewWindow("Face Detect")
	defer window.Close()

	// prepare image matrix
	img := gocv.NewMat()
	defer img.Close()

	// color for the rect when faces detected
	blue := color.RGBA{0, 0, 255, 0}

	// load classifier to recognize faces
	classifier := gocv.NewCascadeClassifier()
	defer classifier.Close()

	if !classifier.Load("data/haarcascade_frontalface_default.xml") {
		fmt.Println("Error reading cascade file: data/haarcascade_frontalface_default.xml")
		return
	}

	fmt.Printf("start reading camera device: %v\n", deviceID)
	for {
		if ok := webcam.Read(&img); !ok {
			fmt.Printf("cannot read device %v\n", deviceID)
			return
		}
		if img.Empty() {
			continue
		}

		// detect faces
		rects := classifier.DetectMultiScale(img)
		fmt.Printf("found %d faces\n", len(rects))

		// draw a rectangle around each face on the original image
		for _, r := range rects {
			gocv.Rectangle(&img, r, blue, 3)
		}

		// show the image in the window, and wait 1 millisecond
		window.IMShow(img)
		window.WaitKey(1)
	}
}
More examples

There are examples in the cmd directory of this repo in the form of various useful command line utilities, such as capturing an image file, streaming mjpeg video, counting objects that cross a line, and using OpenCV with Tensorflow for object classification.

How to install

To install GoCV, run the following command:

go get -u -d gocv.io/x/gocv

To run code that uses the GoCV package, you must also install OpenCV 4.5.2 on your system. Here are instructions for Ubuntu, Raspian, macOS, and Windows.

Ubuntu/Linux

Installation

You can use make to install OpenCV 4.5.2 with the handy Makefile included with this repo. If you already have installed OpenCV, you do not need to do so again. The installation performed by the Makefile is minimal, so it may remove OpenCV options such as Python or Java wrappers if you have already installed OpenCV some other way.

Quick Install

The following commands should do everything to download and install OpenCV 4.5.2 on Linux:

cd $GOPATH/src/gocv.io/x/gocv
make install

If you need static opencv libraries

make install BUILD_SHARED_LIBS=OFF

If it works correctly, at the end of the entire process, the following message should be displayed:

gocv version: 0.27.0
opencv lib version: 4.5.2

That's it, now you are ready to use GoCV.

Using CUDA with GoCV

See the cuda directory for information.

Using OpenVINO with GoCV

See the openvino directory for information.

Make Install for OpenVINO and Cuda
The following commands should do everything to download and install OpenCV 4.5.2 with CUDA and OpenVINO on Linux:

cd $GOPATH/src/gocv.io/x/gocv
make install_all

If you need static opencv libraries

make install_all BUILD_SHARED_LIBS=OFF

If it works correctly, at the end of the entire process, the following message should be displayed:

gocv version: 0.27.0
opencv lib version: 4.5.2-openvino
cuda information:
  Device 0:  "GeForce MX150"  2003Mb, sm_61, Driver/Runtime ver.10.0/10.0
Complete Install

If you have already done the "Quick Install" as described above, you do not need to run any further commands. For the curious, or for custom installations, here are the details for each of the steps that are performed when you run make install.

Install required packages

First, you need to change the current directory to the location of the GoCV repo, so you can access the Makefile:

cd $GOPATH/src/gocv.io/x/gocv

Next, you need to update the system, and install any required packages:

make deps
Download source

Now, download the OpenCV 4.5.2 and OpenCV Contrib source code:

make download
Build

Build everything. This will take quite a while:

make build

If you need static opencv libraries

make build BUILD_SHARED_LIBS=OFF
Install

Once the code is built, you are ready to install:

make sudo_install
Verifying the installation

To verify your installation you can run one of the included examples.

First, change the current directory to the location of the GoCV repo:

cd $GOPATH/src/gocv.io/x/gocv

Now you should be able to build or run any of the examples:

go run ./cmd/version/main.go

The version program should output the following:

gocv version: 0.27.0
opencv lib version: 4.5.2
Cleanup extra files

After the installation is complete, you can remove the extra files and folders:

make clean
Cache builds

If you are running a version of Go older than v1.10 and not modifying GoCV source, precompile the GoCV package to significantly decrease your build times:

go install gocv.io/x/gocv
Custom Environment

By default, pkg-config is used to determine the correct flags for compiling and linking OpenCV. This behavior can be disabled by supplying -tags customenv when building/running your application. When building with this tag you will need to supply the CGO environment variables yourself.

For example:

export CGO_CPPFLAGS="-I/usr/local/include"
export CGO_LDFLAGS="-L/usr/local/lib -lopencv_core -lopencv_face -lopencv_videoio -lopencv_imgproc -lopencv_highgui -lopencv_imgcodecs -lopencv_objdetect -lopencv_features2d -lopencv_video -lopencv_dnn -lopencv_xfeatures2d"

Please note that you will need to run these 2 lines of code one time in your current session in order to build or run the code, in order to setup the needed ENV variables. Once you have done so, you can execute code that uses GoCV with your custom environment like this:

go run -tags customenv ./cmd/version/main.go
Docker

The project now provides Dockerfile which lets you build GoCV Docker image which you can then use to build and run GoCV applications in Docker containers. The Makefile contains docker target which lets you build Docker image with a single command:

make docker

By default Docker image built by running the command above ships Go version 1.13.5, but if you would like to build an image which uses different version of Go you can override the default value when running the target command:

make docker GOVERSION='1.13.5'
Running GUI programs in Docker on macOS

Sometimes your GoCV programs create graphical interfaces like windows eg. when you use gocv.Window type when you display an image or video stream. Running the programs which create graphical interfaces in Docker container on macOS is unfortunately a bit elaborate, but not impossible. First you need to satisfy the following prerequisites:

  • install xquartz. You can also install xquartz using homebrew by running brew cask install xquartz
  • install socat brew install socat

Note, you will have to log out and log back in to your machine once you have installed xquartz. This is so the X window system is reloaded.

Once you have installed all the prerequisites you need to allow connections from network clients to xquartz. Here is how you do that. First run the following command to open xquart so you can configure it:

open -a xquartz

Click on Security tab in preferences and check the "Allow connections" box:

app image

Next, you need to create a TCP proxy using socat which will stream X Window data into xquart. Before you start the proxy you need to make sure that there is no process listening in port 6000. The following command should not return any results:

lsof -i TCP:6000

Now you can start a local proxy which will proxy the X Window traffic into xquartz which acts a your local X server:

socat TCP-LISTEN:6000,reuseaddr,fork UNIX-CLIENT:\"$DISPLAY\"

You are now finally ready to run your GoCV GUI programs in Docker containers. In order to make everything work you must set DISPLAY environment variables as shown in a sample command below:

docker run -it --rm -e DISPLAY=docker.for.mac.host.internal:0 your-gocv-app

Note, since Docker for MacOS does not provide any video device support, you won't be able run GoCV apps which require camera.

Alpine 3.7 Docker image

There is a Docker image with Alpine 3.7 that has been created by project contributor @denismakogon. You can find it located at https://github.com/denismakogon/gocv-alpine.

Raspbian

Installation

We have a special installation for the Raspberry Pi that includes some hardware optimizations. You use make to install OpenCV 4.5.2 with the handy Makefile included with this repo. If you already have installed OpenCV, you do not need to do so again. The installation performed by the Makefile is minimal, so it may remove OpenCV options such as Python or Java wrappers if you have already installed OpenCV some other way.

Quick Install

The following commands should do everything to download and install OpenCV 4.5.2 on Raspbian:

cd $GOPATH/src/gocv.io/x/gocv
make install_raspi

If it works correctly, at the end of the entire process, the following message should be displayed:

gocv version: 0.27.0
opencv lib version: 4.5.2

That's it, now you are ready to use GoCV.

macOS

Installation

You can install OpenCV 4.5.2 using Homebrew.

If you already have an earlier version of OpenCV (3.4.x) installed, you should probably remove it before installing the new version:

brew uninstall opencv

You can then install OpenCV 4.5.2:

brew install opencv
pkgconfig Installation

pkg-config is used to determine the correct flags for compiling and linking OpenCV. You can install it by using Homebrew:

brew install pkgconfig
Verifying the installation

To verify your installation you can run one of the included examples.

First, change the current directory to the location of the GoCV repo:

cd $GOPATH/src/gocv.io/x/gocv

Now you should be able to build or run any of the examples:

go run ./cmd/version/main.go

The version program should output the following:

gocv version: 0.27.0
opencv lib version: 4.5.2
Cache builds

If you are running a version of Go older than v1.10 and not modifying GoCV source, precompile the GoCV package to significantly decrease your build times:

go install gocv.io/x/gocv
Custom Environment

By default, pkg-config is used to determine the correct flags for compiling and linking OpenCV. This behavior can be disabled by supplying -tags customenv when building/running your application. When building with this tag you will need to supply the CGO environment variables yourself.

For example:

export CGO_CXXFLAGS="--std=c++11"
export CGO_CPPFLAGS="-I/usr/local/Cellar/opencv/4.5.2/include"
export CGO_LDFLAGS="-L/usr/local/Cellar/opencv/4.5.2/lib -lopencv_stitching -lopencv_superres -lopencv_videostab -lopencv_aruco -lopencv_bgsegm -lopencv_bioinspired -lopencv_ccalib -lopencv_dnn_objdetect -lopencv_dpm -lopencv_face -lopencv_photo -lopencv_fuzzy -lopencv_hfs -lopencv_img_hash -lopencv_line_descriptor -lopencv_optflow -lopencv_reg -lopencv_rgbd -lopencv_saliency -lopencv_stereo -lopencv_structured_light -lopencv_phase_unwrapping -lopencv_surface_matching -lopencv_tracking -lopencv_datasets -lopencv_dnn -lopencv_plot -lopencv_xfeatures2d -lopencv_shape -lopencv_video -lopencv_ml -lopencv_ximgproc -lopencv_calib3d -lopencv_features2d -lopencv_highgui -lopencv_videoio -lopencv_flann -lopencv_xobjdetect -lopencv_imgcodecs -lopencv_objdetect -lopencv_xphoto -lopencv_imgproc -lopencv_core"

Please note that you will need to run these 3 lines of code one time in your current session in order to build or run the code, in order to setup the needed ENV variables. Once you have done so, you can execute code that uses GoCV with your custom environment like this:

go run -tags customenv ./cmd/version/main.go

Windows

Installation

The following assumes that you are running a 64-bit version of Windows 10.

In order to build and install OpenCV 4.5.2 on Windows, you must first download and install MinGW-W64 and CMake, as follows.

MinGW-W64

Download and run the MinGW-W64 compiler installer from https://sourceforge.net/projects/mingw-w64/files/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/7.3.0/.

The latest version of the MinGW-W64 toolchain is 7.3.0, but any version from 7.X on should work.

Choose the options for "posix" threads, and for "seh" exceptions handling, then install to the default location c:\Program Files\mingw-w64\x86_64-7.3.0-posix-seh-rt_v5-rev2.

Add the C:\Program Files\mingw-w64\x86_64-7.3.0-posix-seh-rt_v5-rev2\mingw64\bin path to your System Path.

CMake

Download and install CMake https://cmake.org/download/ to the default location. CMake installer will add CMake to your system path.

OpenCV 4.5.2 and OpenCV Contrib Modules

The following commands should do everything to download and install OpenCV 4.5.2 on Windows:

chdir %GOPATH%\src\gocv.io\x\gocv
win_build_opencv.cmd

It might take up to one hour.

Last, add C:\opencv\build\install\x64\mingw\bin to your System Path.

Verifying the installation

Change the current directory to the location of the GoCV repo:

chdir %GOPATH%\src\gocv.io\x\gocv

Now you should be able to build or run any of the command examples:

go run cmd\version\main.go

The version program should output the following:

gocv version: 0.27.0
opencv lib version: 4.5.2

That's it, now you are ready to use GoCV.

Cache builds

If you are running a version of Go older than v1.10 and not modifying GoCV source, precompile the GoCV package to significantly decrease your build times:

go install gocv.io/x/gocv
Custom Environment

By default, OpenCV is expected to be in C:\opencv\build\install\include. This behavior can be disabled by supplying -tags customenv when building/running your application. When building with this tag you will need to supply the CGO environment variables yourself.

Due to the way OpenCV produces DLLs, including the version in the name, using this method is required if you're using a different version of OpenCV.

For example:

set CGO_CXXFLAGS="--std=c++11"
set CGO_CPPFLAGS=-IC:\opencv\build\install\include
set CGO_LDFLAGS=-LC:\opencv\build\install\x64\mingw\lib -lopencv_core412 -lopencv_face412 -lopencv_videoio412 -lopencv_imgproc412 -lopencv_highgui412 -lopencv_imgcodecs412 -lopencv_objdetect412 -lopencv_features2d412 -lopencv_video412 -lopencv_dnn412 -lopencv_xfeatures2d412 -lopencv_plot412 -lopencv_tracking412 -lopencv_img_hash412

Please note that you will need to run these 3 lines of code one time in your current session in order to build or run the code, in order to setup the needed ENV variables. Once you have done so, you can execute code that uses GoCV with your custom environment like this:

go run -tags customenv cmd\version\main.go

Android

There is some work in progress for running GoCV on Android using Gomobile. For information on how to install OpenCV/GoCV for Android, please see: https://gist.github.com/ogero/c19458cf64bd3e91faae85c3ac887481

See original discussion here: https://github.com/hybridgroup/gocv/issues/235

Profiling

Since memory allocations for images in GoCV are done through C based code, the go garbage collector will not clean all resources associated with a Mat. As a result, any Mat created must be closed to avoid memory leaks.

To ease the detection and repair of the resource leaks, GoCV provides a Mat profiler that records when each Mat is created and closed. Each time a Mat is allocated, the stack trace is added to the profile. When it is closed, the stack trace is removed. See the runtime/pprof documentation.

In order to include the MatProfile custom profiler, you MUST build or run your application or tests using the -tags matprofile build tag. For example:

go run -tags matprofile cmd/version/main.go

You can get the profile's count at any time using:

gocv.MatProfile.Count()

You can display the current entries (the stack traces) with:

var b bytes.Buffer
gocv.MatProfile.WriteTo(&b, 1)
fmt.Print(b.String())

This can be very helpful to track down a leak. For example, suppose you have the following nonsense program:

package main

import (
	"bytes"
	"fmt"

	"gocv.io/x/gocv"
)

func leak() {
	gocv.NewMat()
}

func main() {
	fmt.Printf("initial MatProfile count: %v\n", gocv.MatProfile.Count())
	leak()

	fmt.Printf("final MatProfile count: %v\n", gocv.MatProfile.Count())
	var b bytes.Buffer
	gocv.MatProfile.WriteTo(&b, 1)
	fmt.Print(b.String())
}

Running this program produces the following output:

initial MatProfile count: 0
final MatProfile count: 1
gocv.io/x/gocv.Mat profile: total 1
1 @ 0x40b936c 0x40b93b7 0x40b94e2 0x40b95af 0x402cd87 0x40558e1
#	0x40b936b	gocv.io/x/gocv.newMat+0x4b	/go/src/gocv.io/x/gocv/core.go:153
#	0x40b93b6	gocv.io/x/gocv.NewMat+0x26	/go/src/gocv.io/x/gocv/core.go:159
#	0x40b94e1	main.leak+0x21			/go/src/github.com/dougnd/gocvprofexample/main.go:11
#	0x40b95ae	main.main+0xae			/go/src/github.com/dougnd/gocvprofexample/main.go:16
#	0x402cd86	runtime.main+0x206		/usr/local/Cellar/go/1.11.1/libexec/src/runtime/proc.go:201

We can see that this program would leak memory. As it exited, it had one Mat that was never closed. The stack trace points to exactly which line the allocation happened on (line 11, the gocv.NewMat()).

Furthermore, if the program is a long running process or if GoCV is being used on a web server, it may be helpful to install the HTTP interface )). For example:

package main

import (
	"net/http"
	_ "net/http/pprof"
	"time"

	"gocv.io/x/gocv"
)

func leak() {
	gocv.NewMat()
}

func main() {
	go func() {
		ticker := time.NewTicker(time.Second)
		for {
			<-ticker.C
			leak()
		}
	}()

	http.ListenAndServe("localhost:6060", nil)
}

This will leak a Mat once per second. You can see the current profile count and stack traces by going to the installed HTTP debug interface: http://localhost:6060/debug/pprof/gocv.io/x/gocv.Mat.

How to contribute

Please take a look at our CONTRIBUTING.md document to understand our contribution guidelines.

Then check out our ROADMAP.md document to know what to work on next.

Why this project exists

The https://github.com/go-opencv/go-opencv package for Go and OpenCV does not support any version above OpenCV 2.x, and work on adding support for OpenCV 3 had stalled for over a year, mostly due to the complexity of SWIG. That is why we started this project.

The GoCV package uses a C-style wrapper around the OpenCV 4 C++ classes to avoid having to deal with applying SWIG to a huge existing codebase. The mappings are intended to match as closely as possible to the original OpenCV project structure, to make it easier to find things, and to be able to figure out where to add support to GoCV for additional OpenCV image filters, algorithms, and other features.

For example, the OpenCV videoio module wrappers can be found in the GoCV package in the videoio.* files.

This package was inspired by the original https://github.com/go-opencv/go-opencv project, the blog post https://medium.com/@peterleyssens/using-opencv-3-from-golang-5510c312a3c and the repo at https://github.com/sensorbee/opencv thank you all!

License

Licensed under the Apache 2.0 license. Copyright (c) 2017-2020 The Hybrid Group.

Logo generated by GopherizeMe - https://gopherize.me

Expand ▾ Collapse ▴

Documentation

Overview

    Package gocv is a wrapper around the OpenCV 4.x computer vision library. It provides a Go language interface to the latest version of OpenCV.

    OpenCV (Open Source Computer Vision Library: http://opencv.org) is an open-source BSD-licensed library that includes several hundreds of computer vision algorithms.

    For further details, please see: http://docs.opencv.org/master/d1/dfb/intro.html

    Index

    Examples

    Constants

    View Source
    const (
    	// MatChannels1 is a single channel Mat.
    	MatChannels1 = 0
    
    	// MatChannels2 is 2 channel Mat.
    	MatChannels2 = 8
    
    	// MatChannels3 is 3 channel Mat.
    	MatChannels3 = 16
    
    	// MatChannels4 is 4 channel Mat.
    	MatChannels4 = 24
    )
    View Source
    const (
    	// MatTypeCV8U is a Mat of 8-bit unsigned int
    	MatTypeCV8U MatType = 0
    
    	// MatTypeCV8S is a Mat of 8-bit signed int
    	MatTypeCV8S MatType = 1
    
    	// MatTypeCV16U is a Mat of 16-bit unsigned int
    	MatTypeCV16U MatType = 2
    
    	// MatTypeCV16S is a Mat of 16-bit signed int
    	MatTypeCV16S MatType = 3
    
    	// MatTypeCV16SC2 is a Mat of 16-bit signed int with 2 channels
    	MatTypeCV16SC2 = MatTypeCV16S + MatChannels2
    
    	// MatTypeCV32S is a Mat of 32-bit signed int
    	MatTypeCV32S MatType = 4
    
    	// MatTypeCV32F is a Mat of 32-bit float
    	MatTypeCV32F MatType = 5
    
    	// MatTypeCV64F is a Mat of 64-bit float
    	MatTypeCV64F MatType = 6
    
    	// MatTypeCV8UC1 is a Mat of 8-bit unsigned int with a single channel
    	MatTypeCV8UC1 = MatTypeCV8U + MatChannels1
    
    	// MatTypeCV8UC2 is a Mat of 8-bit unsigned int with 2 channels
    	MatTypeCV8UC2 = MatTypeCV8U + MatChannels2
    
    	// MatTypeCV8UC3 is a Mat of 8-bit unsigned int with 3 channels
    	MatTypeCV8UC3 = MatTypeCV8U + MatChannels3
    
    	// MatTypeCV8UC4 is a Mat of 8-bit unsigned int with 4 channels
    	MatTypeCV8UC4 = MatTypeCV8U + MatChannels4
    
    	// MatTypeCV8SC1 is a Mat of 8-bit signed int with a single channel
    	MatTypeCV8SC1 = MatTypeCV8S + MatChannels1
    
    	// MatTypeCV8SC2 is a Mat of 8-bit signed int with 2 channels
    	MatTypeCV8SC2 = MatTypeCV8S + MatChannels2
    
    	// MatTypeCV8SC3 is a Mat of 8-bit signed int with 3 channels
    	MatTypeCV8SC3 = MatTypeCV8S + MatChannels3
    
    	// MatTypeCV8SC4 is a Mat of 8-bit signed int with 4 channels
    	MatTypeCV8SC4 = MatTypeCV8S + MatChannels4
    
    	// MatTypeCV16UC1 is a Mat of 16-bit unsigned int with a single channel
    	MatTypeCV16UC1 = MatTypeCV16U + MatChannels1
    
    	// MatTypeCV16UC2 is a Mat of 16-bit unsigned int with 2 channels
    	MatTypeCV16UC2 = MatTypeCV16U + MatChannels2
    
    	// MatTypeCV16UC3 is a Mat of 16-bit unsigned int with 3 channels
    	MatTypeCV16UC3 = MatTypeCV16U + MatChannels3
    
    	// MatTypeCV16UC4 is a Mat of 16-bit unsigned int with 4 channels
    	MatTypeCV16UC4 = MatTypeCV16U + MatChannels4
    
    	// MatTypeCV16SC1 is a Mat of 16-bit signed int with a single channel
    	MatTypeCV16SC1 = MatTypeCV16S + MatChannels1
    
    	// MatTypeCV16SC3 is a Mat of 16-bit signed int with 3 channels
    	MatTypeCV16SC3 = MatTypeCV16S + MatChannels3
    
    	// MatTypeCV16SC4 is a Mat of 16-bit signed int with 4 channels
    	MatTypeCV16SC4 = MatTypeCV16S + MatChannels4
    
    	// MatTypeCV32SC1 is a Mat of 32-bit signed int with a single channel
    	MatTypeCV32SC1 = MatTypeCV32S + MatChannels1
    
    	// MatTypeCV32SC2 is a Mat of 32-bit signed int with 2 channels
    	MatTypeCV32SC2 = MatTypeCV32S + MatChannels2
    
    	// MatTypeCV32SC3 is a Mat of 32-bit signed int with 3 channels
    	MatTypeCV32SC3 = MatTypeCV32S + MatChannels3
    
    	// MatTypeCV32SC4 is a Mat of 32-bit signed int with 4 channels
    	MatTypeCV32SC4 = MatTypeCV32S + MatChannels4
    
    	// MatTypeCV32FC1 is a Mat of 32-bit float int with a single channel
    	MatTypeCV32FC1 = MatTypeCV32F + MatChannels1
    
    	// MatTypeCV32FC2 is a Mat of 32-bit float int with 2 channels
    	MatTypeCV32FC2 = MatTypeCV32F + MatChannels2
    
    	// MatTypeCV32FC3 is a Mat of 32-bit float int with 3 channels
    	MatTypeCV32FC3 = MatTypeCV32F + MatChannels3
    
    	// MatTypeCV32FC4 is a Mat of 32-bit float int with 4 channels
    	MatTypeCV32FC4 = MatTypeCV32F + MatChannels4
    
    	// MatTypeCV64FC1 is a Mat of 64-bit float int with a single channel
    	MatTypeCV64FC1 = MatTypeCV64F + MatChannels1
    
    	// MatTypeCV64FC2 is a Mat of 64-bit float int with 2 channels
    	MatTypeCV64FC2 = MatTypeCV64F + MatChannels2
    
    	// MatTypeCV64FC3 is a Mat of 64-bit float int with 3 channels
    	MatTypeCV64FC3 = MatTypeCV64F + MatChannels3
    
    	// MatTypeCV64FC4 is a Mat of 64-bit float int with 4 channels
    	MatTypeCV64FC4 = MatTypeCV64F + MatChannels4
    )
    View Source
    const (
    	//IMWriteJpegQuality is the quality from 0 to 100 for JPEG (the higher is the better). Default value is 95.
    	IMWriteJpegQuality = 1
    
    	// IMWriteJpegProgressive enables JPEG progressive feature, 0 or 1, default is False.
    	IMWriteJpegProgressive = 2
    
    	// IMWriteJpegOptimize enables JPEG optimization, 0 or 1, default is False.
    	IMWriteJpegOptimize = 3
    
    	// IMWriteJpegRstInterval is the JPEG restart interval, 0 - 65535, default is 0 - no restart.
    	IMWriteJpegRstInterval = 4
    
    	// IMWriteJpegLumaQuality separates luma quality level, 0 - 100, default is 0 - don't use.
    	IMWriteJpegLumaQuality = 5
    
    	// IMWriteJpegChromaQuality separates chroma quality level, 0 - 100, default is 0 - don't use.
    	IMWriteJpegChromaQuality = 6
    
    	// IMWritePngCompression is the compression level from 0 to 9 for PNG. A
    	// higher value means a smaller size and longer compression time.
    	// If specified, strategy is changed to IMWRITE_PNG_STRATEGY_DEFAULT (Z_DEFAULT_STRATEGY).
    	// Default value is 1 (best speed setting).
    	IMWritePngCompression = 16
    
    	// IMWritePngStrategy is one of cv::IMWritePNGFlags, default is IMWRITE_PNG_STRATEGY_RLE.
    	IMWritePngStrategy = 17
    
    	// IMWritePngBilevel is the binary level PNG, 0 or 1, default is 0.
    	IMWritePngBilevel = 18
    
    	// IMWritePxmBinary for PPM, PGM, or PBM can be a binary format flag, 0 or 1. Default value is 1.
    	IMWritePxmBinary = 32
    
    	// IMWriteWebpQuality is the quality from 1 to 100 for WEBP (the higher is
    	// the better). By default (without any parameter) and for quality above
    	// 100 the lossless compression is used.
    	IMWriteWebpQuality = 64
    
    	// IMWritePamTupletype sets the TUPLETYPE field to the corresponding string
    	// value that is defined for the format.
    	IMWritePamTupletype = 128
    
    	// IMWritePngStrategyDefault is the value to use for normal data.
    	IMWritePngStrategyDefault = 0
    
    	// IMWritePngStrategyFiltered is the value to use for data produced by a
    	// filter (or predictor). Filtered data consists mostly of small values
    	// with a somewhat random distribution. In this case, the compression
    	// algorithm is tuned to compress them better.
    	IMWritePngStrategyFiltered = 1
    
    	// IMWritePngStrategyHuffmanOnly forces Huffman encoding only (no string match).
    	IMWritePngStrategyHuffmanOnly = 2
    
    	// IMWritePngStrategyRle is the value to use to limit match distances to
    	// one (run-length encoding).
    	IMWritePngStrategyRle = 3
    
    	// IMWritePngStrategyFixed is the value to prevent the use of dynamic
    	// Huffman codes, allowing for a simpler decoder for special applications.
    	IMWritePngStrategyFixed = 4
    )
    View Source
    const (
    	OptflowUseInitialFlow    = 4
    	OptflowLkGetMinEigenvals = 8
    	OptflowFarnebackGaussian = 256
    )

      *

      cv::OPTFLOW_USE_INITIAL_FLOW = 4,
      cv::OPTFLOW_LK_GET_MIN_EIGENVALS = 8,
      cv::OPTFLOW_FARNEBACK_GAUSSIAN = 256
      For further details, please see: https://docs.opencv.org/master/dc/d6b/group__video__track.html#gga2c6cc144c9eee043575d5b311ac8af08a9d4430ac75199af0cf6fcdefba30eafe
      
      View Source
      const GoCVVersion = "0.27.0"

        GoCVVersion of this package, for display purposes.

        Variables

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

        Functions

        func AbsDiff

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

          AbsDiff calculates the per-element absolute difference between two arrays or between an array and a scalar.

          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6fef31bc8c4071cbc114a758a2b79c14

          func Accumulate

          func Accumulate(src Mat, dst *Mat)

          func AccumulateProduct

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

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

            For further details, please see: https://docs.opencv.org/master/d7/df3/group__imgproc__motion.html#ga82518a940ecfda49460f66117ac82520

            func AccumulateProductWithMask

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

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

              For further details, please see: https://docs.opencv.org/master/d7/df3/group__imgproc__motion.html#ga82518a940ecfda49460f66117ac82520

              func AccumulateSquare

              func AccumulateSquare(src Mat, dst *Mat)

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

                For further details, please see: https://docs.opencv.org/master/d7/df3/group__imgproc__motion.html#gacb75e7ffb573227088cef9ceaf80be8c

                func AccumulateSquareWithMask

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

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

                  For further details, please see: https://docs.opencv.org/master/d7/df3/group__imgproc__motion.html#gacb75e7ffb573227088cef9ceaf80be8c

                  func AccumulateWithMask

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

                    Adds an image to the accumulator image with mask.

                    For further details, please see: https://docs.opencv.org/master/d7/df3/group__imgproc__motion.html#ga1a567a79901513811ff3b9976923b199

                    func AccumulatedWeighted

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

                      Updates a running average.

                      For further details, please see: https://docs.opencv.org/master/d7/df3/group__imgproc__motion.html#ga4f9552b541187f61f6818e8d2d826bc7

                      func AccumulatedWeightedWithMask

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

                        Updates a running average with mask.

                        For further details, please see: https://docs.opencv.org/master/d7/df3/group__imgproc__motion.html#ga4f9552b541187f61f6818e8d2d826bc7

                        func AdaptiveThreshold

                        func AdaptiveThreshold(src Mat, dst *Mat, maxValue float32, adaptiveTyp AdaptiveThresholdType, typ ThresholdType, blockSize int, c float32)

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

                          For further details, please see: https://docs.opencv.org/master/d7/d1b/group__imgproc__misc.html#ga72b913f352e4a1b1b397736707afcde3

                          func Add

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

                            Add calculates the per-element sum of two arrays or an array and a scalar.

                            For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga10ac1bfb180e2cfda1701d06c24fdbd6

                            func AddWeighted

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

                              AddWeighted calculates the weighted sum of two arrays.

                              For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gafafb2513349db3bcff51f54ee5592a19

                              func ApplyColorMap

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

                                ApplyColorMap applies a GNU Octave/MATLAB equivalent colormap on a given image.

                                For further details, please see: https://docs.opencv.org/master/d3/d50/group__imgproc__colormap.html#gadf478a5e5ff49d8aa24e726ea6f65d15

                                func ApplyCustomColorMap

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

                                  ApplyCustomColorMap applies a custom defined colormap on a given image.

                                  For further details, please see: https://docs.opencv.org/master/d3/d50/group__imgproc__colormap.html#gacb22288ddccc55f9bd9e6d492b409cae

                                  func ArcLength

                                  func ArcLength(curve PointVector, isClosed bool) float64

                                    ArcLength calculates a contour perimeter or a curve length.

                                    For further details, please see:

                                    https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#ga8d26483c636be6b35c3ec6335798a47c

                                    func ArrowedLine

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

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

                                      For further details, please see: https://docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#ga0a165a3ca093fd488ac709fdf10c05b2

                                      func BatchDistance

                                      func BatchDistance(src1 Mat, src2 Mat, dist Mat, dtype MatType, nidx Mat, normType NormType, K int, mask Mat, update int, crosscheck bool)

                                        BatchDistance is a naive nearest neighbor finder.

                                        For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga4ba778a1c57f83233b1d851c83f5a622

                                        func BilateralFilter

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

                                          BilateralFilter applies a bilateral filter to an image.

                                          Bilateral filtering is described here: http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html

                                          BilateralFilter can reduce unwanted noise very well while keeping edges fairly sharp. However, it is very slow compared to most filters.

                                          For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga9d7064d478c95d60003cf839430737ed

                                          func BitwiseAnd

                                          func BitwiseAnd(src1 Mat, src2 Mat, dst *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.

                                            For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga60b4d04b251ba5eb1392c34425497e14

                                            func BitwiseAndWithMask

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

                                              BitwiseAndWithMask 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. It has an additional parameter for a mask.

                                              For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga60b4d04b251ba5eb1392c34425497e14

                                              func BitwiseNot

                                              func BitwiseNot(src1 Mat, dst *Mat)

                                                BitwiseNot inverts every bit of an array.

                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga0002cf8b418479f4cb49a75442baee2f

                                                func BitwiseNotWithMask

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

                                                  BitwiseNotWithMask inverts every bit of an array. It has an additional parameter for a mask.

                                                  For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga0002cf8b418479f4cb49a75442baee2f

                                                  func BitwiseOr

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

                                                    BitwiseOr calculates the per-element bit-wise disjunction of two arrays or an array and a scalar.

                                                    For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gab85523db362a4e26ff0c703793a719b4

                                                    func BitwiseOrWithMask

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

                                                      BitwiseOrWithMask calculates the per-element bit-wise disjunction of two arrays or an array and a scalar. It has an additional parameter for a mask.

                                                      For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gab85523db362a4e26ff0c703793a719b4

                                                      func BitwiseXor

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

                                                        BitwiseXor calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar.

                                                        For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga84b2d8188ce506593dcc3f8cd00e8e2c

                                                        func BitwiseXorWithMask

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

                                                          BitwiseXorWithMask calculates the per-element bit-wise "exclusive or" operation on two arrays or an array and a scalar. It has an additional parameter for a mask.

                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga84b2d8188ce506593dcc3f8cd00e8e2c

                                                          func BlobFromImages

                                                          func BlobFromImages(imgs []Mat, blob *Mat, scaleFactor float64, size image.Point, mean Scalar,
                                                          	swapRB bool, crop bool, ddepth MatType)

                                                            BlobFromImages 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.

                                                            For further details, please see: https://docs.opencv.org/master/d6/d0f/group__dnn.html#ga2b89ed84432e4395f5a1412c2926293c

                                                            func Blur

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

                                                              Blur blurs an image Mat using a normalized box filter.

                                                              For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga8c45db9afe636703801b0b2e440fce37

                                                              func BorderInterpolate

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

                                                                BorderInterpolate computes the source location of an extrapolated pixel.

                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga247f571aa6244827d3d798f13892da58

                                                                func BoundingRect

                                                                func BoundingRect(contour PointVector) image.Rectangle

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

                                                                  For further details, please see: https://docs.opencv.org/3.3.0/d3/dc0/group__imgproc__shape.html#gacb413ddce8e48ff3ca61ed7cf626a366

                                                                  func BoxFilter

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

                                                                    BoxFilter blurs an image using the box filter.

                                                                    For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gad533230ebf2d42509547d514f7d3fbc3

                                                                    func BoxPoints

                                                                    func BoxPoints(rect RotatedRect, pts *Mat)

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

                                                                      For further Details, please see: https://docs.opencv.org/3.3.0/d3/dc0/group__imgproc__shape.html#gaf78d467e024b4d7936cf9397185d2f5c

                                                                      func CalcBackProject

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

                                                                        CalcBackProject calculates the back projection of a histogram.

                                                                        For futher details, please see: https://docs.opencv.org/3.4/d6/dc7/group__imgproc__hist.html#ga3a0af640716b456c3d14af8aee12e3ca

                                                                        func CalcCovarMatrix

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

                                                                          CalcCovarMatrix calculates the covariance matrix of a set of vectors.

                                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga017122d912af19d7d0d2cccc2d63819f

                                                                          func CalcHist

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

                                                                            CalcHist Calculates a histogram of a set of images

                                                                            For futher details, please see: https://docs.opencv.org/master/d6/dc7/group__imgproc__hist.html#ga6ca1876785483836f72a77ced8ea759a

                                                                            func CalcOpticalFlowFarneback

                                                                            func CalcOpticalFlowFarneback(prevImg Mat, nextImg Mat, flow *Mat, pyrScale float64, levels int, winsize int,
                                                                            	iterations int, polyN int, polySigma float64, flags int)

                                                                              CalcOpticalFlowFarneback computes a dense optical flow using Gunnar Farneback's algorithm.

                                                                              For further details, please see: https://docs.opencv.org/master/dc/d6b/group__video__track.html#ga5d10ebbd59fe09c5f650289ec0ece5af

                                                                              func CalcOpticalFlowPyrLK

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

                                                                                CalcOpticalFlowPyrLK calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids.

                                                                                For further details, please see: https://docs.opencv.org/master/dc/d6b/group__video__track.html#ga473e4b886d0bcc6b65831eb88ed93323

                                                                                func CalcOpticalFlowPyrLKWithParams

                                                                                func CalcOpticalFlowPyrLKWithParams(prevImg Mat, nextImg Mat, prevPts Mat, nextPts Mat, status *Mat, err *Mat,
                                                                                	winSize image.Point, maxLevel int, criteria TermCriteria, flags int, minEigThreshold float64)

                                                                                  CalcOpticalFlowPyrLKWithParams calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids.

                                                                                  For further details, please see: https://docs.opencv.org/master/dc/d6b/group__video__track.html#ga473e4b886d0bcc6b65831eb88ed93323

                                                                                  func Canny

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

                                                                                    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

                                                                                    For further details, please see: http://docs.opencv.org/master/dd/d1a/group__imgproc__feature.html#ga04723e007ed888ddf11d9ba04e2232de

                                                                                    func CartToPolar

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

                                                                                      CartToPolar calculates the magnitude and angle of 2D vectors.

                                                                                      For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gac5f92f48ec32cacf5275969c33ee837d

                                                                                      func CheckRange

                                                                                      func CheckRange(src Mat) bool

                                                                                        CheckRange checks every element of an input array for invalid values.

                                                                                        For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga2bd19d89cae59361416736f87e3c7a64

                                                                                        func Circle

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

                                                                                          Circle draws a circle.

                                                                                          For further details, please see: https://docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#gaf10604b069374903dbd0f0488cb43670

                                                                                          func ClipLine

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

                                                                                            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

                                                                                            func ColorChange

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

                                                                                              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

                                                                                              func Compare

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

                                                                                                Compare performs the per-element comparison of two arrays or an array and scalar value.

                                                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga303cfb72acf8cbb36d884650c09a3a97

                                                                                                func CompareHist

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

                                                                                                  CompareHist Compares two histograms.

                                                                                                  For further details, please see: https://docs.opencv.org/master/d6/dc7/group__imgproc__hist.html#gaf4190090efa5c47cb367cf97a9a519bd

                                                                                                  func CompleteSymm

                                                                                                  func CompleteSymm(m Mat, lowerToUpper bool)

                                                                                                    CompleteSymm copies the lower or the upper half of a square matrix to its another half.

                                                                                                    For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaa9d88dcd0e54b6d1af38d41f2a3e3d25

                                                                                                    func ConnectedComponents

                                                                                                    func ConnectedComponents(src Mat, labels *Mat) int

                                                                                                      ConnectedComponents computes the connected components labeled image of boolean image.

                                                                                                      For further details, please see: https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5

                                                                                                      func ConnectedComponentsWithParams

                                                                                                      func ConnectedComponentsWithParams(src Mat, labels *Mat, conn int, ltype MatType,
                                                                                                      	ccltype ConnectedComponentsAlgorithmType) int

                                                                                                        ConnectedComponents computes the connected components labeled image of boolean image.

                                                                                                        For further details, please see: https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#gaedef8c7340499ca391d459122e51bef5

                                                                                                        func ConnectedComponentsWithStats

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

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

                                                                                                          For further details, please see: https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#ga107a78bf7cd25dec05fb4dfc5c9e765f

                                                                                                          func ConnectedComponentsWithStatsWithParams

                                                                                                          func ConnectedComponentsWithStatsWithParams(src Mat, labels *Mat, stats *Mat, centroids *Mat,
                                                                                                          	conn int, ltype MatType, ccltype ConnectedComponentsAlgorithmType) int

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

                                                                                                            For further details, please see: https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#ga107a78bf7cd25dec05fb4dfc5c9e765f

                                                                                                            func ContourArea

                                                                                                            func ContourArea(contour PointVector) float64

                                                                                                              ContourArea calculates a contour area.

                                                                                                              For further details, please see: https://docs.opencv.org/3.3.0/d3/dc0/group__imgproc__shape.html#ga2c759ed9f497d4a618048a2f56dc97f1

                                                                                                              func ConvertScaleAbs

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

                                                                                                                ConvertScaleAbs scales, calculates absolute values, and converts the result to 8-bit.

                                                                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga3460e9c9f37b563ab9dd550c4d8c4e7d

                                                                                                                func ConvexHull

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

                                                                                                                  ConvexHull finds the convex hull of a point set.

                                                                                                                  For further details, please see: https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#ga014b28e56cb8854c0de4a211cb2be656

                                                                                                                  func ConvexityDefects

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

                                                                                                                    ConvexityDefects finds the convexity defects of a contour.

                                                                                                                    For further details, please see: https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#gada4437098113fd8683c932e0567f47ba

                                                                                                                    func CopyMakeBorder

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

                                                                                                                      CopyMakeBorder forms a border around an image (applies padding).

                                                                                                                      For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga2ac1049c2c3dd25c2b41bffe17658a36

                                                                                                                      func CornerSubPix

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

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

                                                                                                                        For further details, please see: https://docs.opencv.org/master/dd/d1a/group__imgproc__feature.html#ga354e0d7c86d0d9da75de9b9701a9a87e

                                                                                                                        func CountNonZero

                                                                                                                        func CountNonZero(src Mat) int

                                                                                                                          CountNonZero counts non-zero array elements.

                                                                                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaa4b89393263bb4d604e0fe5986723914

                                                                                                                          func CvtColor

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

                                                                                                                            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.

                                                                                                                            For further details, please see: http://docs.opencv.org/master/d7/d1b/group__imgproc__misc.html#ga4e0972be5de079fed4e3a10e24ef5ef0

                                                                                                                            func DCT

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

                                                                                                                              DCT performs a forward or inverse discrete Cosine transform of 1D or 2D array.

                                                                                                                              For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga85aad4d668c01fbd64825f589e3696d4

                                                                                                                              func DFT

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

                                                                                                                                DFT performs a forward or inverse Discrete Fourier Transform (DFT) of a 1D or 2D floating-point array.

                                                                                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gadd6cf9baf2b8b704a11b5f04aaf4f39d

                                                                                                                                func Determinant

                                                                                                                                func Determinant(src Mat) float64

                                                                                                                                  Determinant returns the determinant of a square floating-point matrix.

                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaf802bd9ca3e07b8b6170645ef0611d0c

                                                                                                                                  func Dilate

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

                                                                                                                                    Dilate dilates an image by using a specific structuring element.

                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga4ff0f3318642c4f469d0e11f242f3b6c

                                                                                                                                    func DistanceTransform

                                                                                                                                    func DistanceTransform(src Mat, dst *Mat, labels *Mat, distType DistanceTypes, maskSize DistanceTransformMasks, labelType DistanceTransformLabelTypes)

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

                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d7/d1b/group__imgproc__misc.html#ga8a0b7fdfcb7a13dde018988ba3a43042

                                                                                                                                      func Divide

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

                                                                                                                                        Divide performs the per-element division on two arrays or an array and a scalar.

                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6db555d30115642fedae0cda05604874

                                                                                                                                        func DrawChessboardCorners

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

                                                                                                                                          DrawChessboardCorners renders the detected chessboard corners.

                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d9/d0c/group__calib3d.html#ga6a10b0bb120c4907e5eabbcd22319022

                                                                                                                                          func DrawContours

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

                                                                                                                                            DrawContours draws contours outlines or filled contours.

                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#ga746c0625f1781f1ffc9056259103edbc

                                                                                                                                            func DrawKeyPoints

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

                                                                                                                                              DrawKeyPoints draws keypoints

                                                                                                                                              For further details please see: https://docs.opencv.org/master/d4/d5d/group__features2d__draw.html#gab958f8900dd10f14316521c149a60433

                                                                                                                                              func DrawMatches

                                                                                                                                              func DrawMatches(img1 Mat, kp1 []KeyPoint, img2 Mat, kp2 []KeyPoint, matches1to2 []DMatch, outImg *Mat, matchColor color.RGBA, singlePointColor color.RGBA, matchesMask []byte, flags DrawMatchesFlag)

                                                                                                                                                DrawMatches draws matches on combined train and querry images.

                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d4/d5d/group__features2d__draw.html#gad8f463ccaf0dc6f61083abd8717c261a

                                                                                                                                                func Eigen

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

                                                                                                                                                  Eigen calculates eigenvalues and eigenvectors of a symmetric matrix.

                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga9fa0d58657f60eaa6c71f6fbb40456e3

                                                                                                                                                  func EigenNonSymmetric

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

                                                                                                                                                    EigenNonSymmetric calculates eigenvalues and eigenvectors of a non-symmetric matrix (real eigenvalues only).

                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaf51987e03cac8d171fbd2b327cf966f6

                                                                                                                                                    func Ellipse

                                                                                                                                                    func Ellipse(img *Mat, center, axes image.Point, angle, startAngle, endAngle float64, c color.RGBA, thickness int)

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

                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#ga28b2267d35786f5f890ca167236cbc69

                                                                                                                                                      func EqualizeHist

                                                                                                                                                      func EqualizeHist(src Mat, dst *Mat)

                                                                                                                                                        EqualizeHist normalizes the brightness and increases the contrast of the image.

                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d6/dc7/group__imgproc__hist.html#ga7e54091f0c937d49bf84152a16f76d6e

                                                                                                                                                        func Erode

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

                                                                                                                                                          Erode erodes an image by using a specific structuring element.

                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gaeb1e0c1033e3f6b891a25d0511362aeb

                                                                                                                                                          func ErodeWithParams

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

                                                                                                                                                            ErodeWithParams erodes an image by using a specific structuring element.

                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gaeb1e0c1033e3f6b891a25d0511362aeb

                                                                                                                                                            func EstimateNewCameraMatrixForUndistortRectify

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

                                                                                                                                                              EstimateNewCameraMatrixForUndistortRectify estimates new camera matrix for undistortion or rectification.

                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/db/d58/group__calib3d__fisheye.html#ga384940fdf04c03e362e94b6eb9b673c9

                                                                                                                                                              func Exp

                                                                                                                                                              func Exp(src Mat, dst *Mat)

                                                                                                                                                                Exp calculates the exponent of every array element.

                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga3e10108e2162c338f1b848af619f39e5

                                                                                                                                                                func ExtractChannel

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

                                                                                                                                                                  ExtractChannel extracts a single channel from src (coi is 0-based index).

                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gacc6158574aa1f0281878c955bcf35642

                                                                                                                                                                  func FP16BlobFromImage

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

                                                                                                                                                                    FP16BlobFromImage is an extended helper function to convert an Image to a half-float blob, as used by the Movidius Neural Compute Stick.

                                                                                                                                                                    func FillPoly

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

                                                                                                                                                                      FillPoly fills the area bounded by one or more polygons.

                                                                                                                                                                      For more information, see: https://docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#gaf30888828337aa4c6b56782b5dfbd4b7

                                                                                                                                                                      func Filter2D

                                                                                                                                                                      func Filter2D(src Mat, dst *Mat, ddepth MatType, kernel Mat, anchor image.Point, delta float64, borderType BorderType)

                                                                                                                                                                        Filter2D applies an arbitrary linear filter to an image.

                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga27c049795ce870216ddfb366086b5a04

                                                                                                                                                                        func FindChessboardCorners

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

                                                                                                                                                                          FindChessboardCorners finds the positions of internal corners of the chessboard.

                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d9/d0c/group__calib3d.html#ga93efa9b0aa890de240ca32b11253dd4a

                                                                                                                                                                          func FindNonZero

                                                                                                                                                                          func FindNonZero(src Mat, idx *Mat)

                                                                                                                                                                            FindNonZero returns the list of locations of non-zero pixels.

                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaed7df59a3539b4cc0fe5c9c8d7586190

                                                                                                                                                                            func FisheyeUndistortImage

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

                                                                                                                                                                              FisheyeUndistortImage transforms an image to compensate for fisheye lens distortion

                                                                                                                                                                              func FisheyeUndistortImageWithParams

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

                                                                                                                                                                                FisheyeUndistortImageWithParams transforms an image to compensate for fisheye lens distortion with Knew matrix

                                                                                                                                                                                func FisheyeUndistortPoints

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

                                                                                                                                                                                  FisheyeUndistortPoints transforms points to compensate for fisheye lens distortion

                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/db/d58/group__calib3d__fisheye.html#gab738cdf90ceee97b2b52b0d0e7511541

                                                                                                                                                                                  func FitLine

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

                                                                                                                                                                                    FitLine fits a line to a 2D or 3D point set.

                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#gaf849da1fdafa67ee84b1e9a23b93f91f

                                                                                                                                                                                    func Flip

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

                                                                                                                                                                                      Flip flips a 2D array around horizontal(0), vertical(1), or both axes(-1).

                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaca7be533e3dac7feb70fc60635adf441

                                                                                                                                                                                      func GaussianBlur

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

                                                                                                                                                                                        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.

                                                                                                                                                                                        For further details, please see: http://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gaabe8c836e97159a9193fb0b11ac52cf1

                                                                                                                                                                                        func Gemm

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

                                                                                                                                                                                          Gemm performs generalized matrix multiplication.

                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gacb6e64071dffe36434e1e7ee79e7cb35

                                                                                                                                                                                          func GetOptimalDFTSize

                                                                                                                                                                                          func GetOptimalDFTSize(vecsize int) int

                                                                                                                                                                                            GetOptimalDFTSize returns the optimal Discrete Fourier Transform (DFT) size for a given vector size.

                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6577a2e59968936ae02eb2edde5de299

                                                                                                                                                                                            func GetRectSubPix

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

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

                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#ga77576d06075c1a4b6ba1a608850cd614

                                                                                                                                                                                              func GetTextSize

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

                                                                                                                                                                                                GetTextSize calculates the width and height of a text string. It returns an image.Point with the size required to draw text using a specific font face, scale, and thickness.

                                                                                                                                                                                                For further details, please see: http://docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#ga3d2abfcb995fd2db908c8288199dba82

                                                                                                                                                                                                func GetTextSizeWithBaseline

                                                                                                                                                                                                func GetTextSizeWithBaseline(text string, fontFace HersheyFont, fontScale float64, thickness int) (image.Point, 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.

                                                                                                                                                                                                  For further details, please see: http://docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#ga3d2abfcb995fd2db908c8288199dba82

                                                                                                                                                                                                  func GetTickCount

                                                                                                                                                                                                  func GetTickCount() float64

                                                                                                                                                                                                    GetTickCount returns the number of ticks.

                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/db/de0/group__core__utils.html#gae73f58000611a1af25dd36d496bf4487

                                                                                                                                                                                                    func GetTickFrequency

                                                                                                                                                                                                    func GetTickFrequency() float64

                                                                                                                                                                                                      GetTickFrequency returns the number of ticks per second.

                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/db/de0/group__core__utils.html#ga705441a9ef01f47acdc55d87fbe5090c

                                                                                                                                                                                                      func GoodFeaturesToTrack

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

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

                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/dd/d1a/group__imgproc__feature.html#ga1d6bb77486c8f92d79c8793ad995d541

                                                                                                                                                                                                        func GrabCut

                                                                                                                                                                                                        func GrabCut(img Mat, mask *Mat, r image.Rectangle, bgdModel *Mat, fgdModel *Mat, iterCount int, mode GrabCutMode)

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

                                                                                                                                                                                                          func GroupRectangles

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

                                                                                                                                                                                                            GroupRectangles groups the object candidate rectangles.

                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d5/d54/group__objdetect.html#ga3dba897ade8aa8227edda66508e16ab9

                                                                                                                                                                                                            func Hconcat

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

                                                                                                                                                                                                              Hconcat applies horizontal concatenation to given matrices.

                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaab5ceee39e0580f879df645a872c6bf7

                                                                                                                                                                                                              func HoughCircles

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

                                                                                                                                                                                                                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`.

                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/dd/d1a/group__imgproc__feature.html#ga47849c3be0d0406ad3ca45db65a25d2d

                                                                                                                                                                                                                func HoughCirclesWithParams

                                                                                                                                                                                                                func HoughCirclesWithParams(src Mat, circles *Mat, method HoughMode, dp, minDist, param1, param2 float64, minRadius, maxRadius int)

                                                                                                                                                                                                                  HoughCirclesWithParams finds circles in a grayscale image using the Hough transform. The only "method" currently supported is HoughGradient.

                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/dd/d1a/group__imgproc__feature.html#ga47849c3be0d0406ad3ca45db65a25d2d

                                                                                                                                                                                                                  func HoughLines

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

                                                                                                                                                                                                                    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

                                                                                                                                                                                                                    For further details, please see: http://docs.opencv.org/master/dd/d1a/group__imgproc__feature.html#ga46b4e588934f6c8dfd509cc6e0e4545a

                                                                                                                                                                                                                    func HoughLinesP

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

                                                                                                                                                                                                                      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

                                                                                                                                                                                                                      For further details, please see: http://docs.opencv.org/master/dd/d1a/group__imgproc__feature.html#ga8618180a5948286384e3b7ca02f6feeb

                                                                                                                                                                                                                      func HoughLinesPWithParams

                                                                                                                                                                                                                      func HoughLinesPWithParams(src Mat, lines *Mat, rho float32, theta float32, threshold int, minLineLength float32, maxLineGap float32)

                                                                                                                                                                                                                      func HoughLinesPointSet

                                                                                                                                                                                                                      func HoughLinesPointSet(points Mat, lines *Mat, linesMax int, threshold int,
                                                                                                                                                                                                                      	minRho float32, maxRho float32, rhoStep float32,
                                                                                                                                                                                                                      	minTheta float32, maxTheta float32, thetaStep float32)

                                                                                                                                                                                                                        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

                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/dd/d1a/group__imgproc__feature.html#ga2858ef61b4e47d1919facac2152a160e

                                                                                                                                                                                                                        func IDCT

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

                                                                                                                                                                                                                          IDCT calculates the inverse Discrete Cosine Transform of a 1D or 2D array.

                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga77b168d84e564c50228b69730a227ef2

                                                                                                                                                                                                                          func IDFT

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

                                                                                                                                                                                                                            IDFT calculates the inverse Discrete Fourier Transform of a 1D or 2D array.

                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaa708aa2d2e57a508f968eb0f69aa5ff1

                                                                                                                                                                                                                            func IMEncode

                                                                                                                                                                                                                            func IMEncode(fileExt FileExt, img Mat) (buf []byte, err error)

                                                                                                                                                                                                                              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.

                                                                                                                                                                                                                              For further details, please see: http://docs.opencv.org/master/d4/da8/group__imgcodecs.html#ga461f9ac09887e47797a54567df3b8b63

                                                                                                                                                                                                                              func IMEncodeWithParams

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

                                                                                                                                                                                                                                IMEncodeWithParams 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.

                                                                                                                                                                                                                                Usage example:

                                                                                                                                                                                                                                buffer, err := gocv.IMEncodeWithParams(gocv.JPEGFileExt, img, []int{gocv.IMWriteJpegQuality, quality})
                                                                                                                                                                                                                                

                                                                                                                                                                                                                                For further details, please see: http://docs.opencv.org/master/d4/da8/group__imgcodecs.html#ga461f9ac09887e47797a54567df3b8b63

                                                                                                                                                                                                                                Example
                                                                                                                                                                                                                                Output:
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                

                                                                                                                                                                                                                                func IMWrite

                                                                                                                                                                                                                                func IMWrite(name string, img Mat) bool

                                                                                                                                                                                                                                  IMWrite writes a Mat to an image file.

                                                                                                                                                                                                                                  For further details, please see: http://docs.opencv.org/master/d4/da8/group__imgcodecs.html#gabbc7ef1aa2edfaa87772f1202d67e0ce

                                                                                                                                                                                                                                  func IMWriteWithParams

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

                                                                                                                                                                                                                                    IMWriteWithParams writes a Mat to an image file. With that func you can pass compression parameters.

                                                                                                                                                                                                                                    For further details, please see: http://docs.opencv.org/master/d4/da8/group__imgcodecs.html#gabbc7ef1aa2edfaa87772f1202d67e0ce

                                                                                                                                                                                                                                    func IlluminationChange

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

                                                                                                                                                                                                                                      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

                                                                                                                                                                                                                                      func ImagesFromBlob

                                                                                                                                                                                                                                      func ImagesFromBlob(blob Mat, imgs []Mat)

                                                                                                                                                                                                                                        ImagesFromBlob Parse a 4D blob and output the images it contains as 2D arrays through a simpler data structure (std::vector<cv::Mat>).

                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d6/d0f/group__dnn.html#ga4051b5fa2ed5f54b76c059a8625df9f5

                                                                                                                                                                                                                                        func InRange

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

                                                                                                                                                                                                                                          InRange checks if array elements lie between the elements of two Mat arrays.

                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga48af0ab51e36436c5d04340e036ce981

                                                                                                                                                                                                                                          func InRangeWithScalar

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

                                                                                                                                                                                                                                            InRangeWithScalar checks if array elements lie between the elements of two Scalars

                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga48af0ab51e36436c5d04340e036ce981

                                                                                                                                                                                                                                            func InitUndistortRectifyMap

                                                                                                                                                                                                                                            func InitUndistortRectifyMap(cameraMatrix Mat, distCoeffs Mat, r Mat, newCameraMatrix Mat, size image.Point, m1type int, map1 Mat, map2 Mat)

                                                                                                                                                                                                                                              InitUndistortRectifyMap computes the joint undistortion and rectification transformation and represents the result in the form of maps for remap

                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d9/d0c/group__calib3d.html#ga7dfb72c9cf9780a347fbe3d1c47e5d5a

                                                                                                                                                                                                                                              func InsertChannel

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

                                                                                                                                                                                                                                                InsertChannel inserts a single channel to dst (coi is 0-based index) (it replaces channel i with another in dst).

                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga1d4bd886d35b00ec0b764cb4ce6eb515

                                                                                                                                                                                                                                                func Integral

                                                                                                                                                                                                                                                func Integral(src Mat, sum *Mat, sqsum *Mat, tilted *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

                                                                                                                                                                                                                                                  func Invert

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

                                                                                                                                                                                                                                                    Invert finds the inverse or pseudo-inverse of a matrix.

                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gad278044679d4ecf20f7622cc151aaaa2

                                                                                                                                                                                                                                                    func InvertAffineTransform

                                                                                                                                                                                                                                                    func InvertAffineTransform(src Mat, dst *Mat)

                                                                                                                                                                                                                                                    func KMeans

                                                                                                                                                                                                                                                    func KMeans(data Mat, k int, bestLabels *Mat, criteria TermCriteria, attempts int, flags KMeansFlags, centers *Mat) float64

                                                                                                                                                                                                                                                      KMeans finds centers of clusters and groups input samples around the clusters.

                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d5/d38/group__core__cluster.html#ga9a34dc06c6ec9460e90860f15bcd2f88

                                                                                                                                                                                                                                                      func KMeansPoints

                                                                                                                                                                                                                                                      func KMeansPoints(points PointVector, k int, bestLabels *Mat, criteria TermCriteria, attempts int, flags KMeansFlags, centers *Mat) float64

                                                                                                                                                                                                                                                        KMeansPoints finds centers of clusters and groups input samples around the clusters.

                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d5/d38/group__core__cluster.html#ga9a34dc06c6ec9460e90860f15bcd2f88

                                                                                                                                                                                                                                                        func LUT

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

                                                                                                                                                                                                                                                          LUT performs a look-up table transform of an array.

                                                                                                                                                                                                                                                          The function LUT fills the output array with values from the look-up table. Indices of the entries are taken from the input array.

                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gab55b8d062b7f5587720ede032d34156f

                                                                                                                                                                                                                                                          func Laplacian

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

                                                                                                                                                                                                                                                            Laplacian calculates the Laplacian of an image.

                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gad78703e4c8fe703d479c1860d76429e6

                                                                                                                                                                                                                                                            func Line

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

                                                                                                                                                                                                                                                              Line draws a line segment connecting two points.

                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#ga7078a9fae8c7e7d13d24dac2520ae4a2

                                                                                                                                                                                                                                                              func LinearPolar

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

                                                                                                                                                                                                                                                                LinearPolar remaps an image to polar coordinates space.

                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#gaa38a6884ac8b6e0b9bed47939b5362f3

                                                                                                                                                                                                                                                                func Log

                                                                                                                                                                                                                                                                func Log(src Mat, dst *Mat)

                                                                                                                                                                                                                                                                  Log calculates the natural logarithm of every array element.

                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga937ecdce4679a77168730830a955bea7

                                                                                                                                                                                                                                                                  func LogPolar

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

                                                                                                                                                                                                                                                                    LogPolar remaps an image to semilog-polar coordinates space.

                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#gaec3a0b126a85b5ca2c667b16e0ae022d

                                                                                                                                                                                                                                                                    func Magnitude

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

                                                                                                                                                                                                                                                                      Magnitude calculates the magnitude of 2D vectors.

                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6d3b097586bca4409873d64a90fe64c3

                                                                                                                                                                                                                                                                      func MatchTemplate

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

                                                                                                                                                                                                                                                                        MatchTemplate compares a template against overlapped image regions.

                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/df/dfb/group__imgproc__object.html#ga586ebfb0a7fb604b35a23d85391329be

                                                                                                                                                                                                                                                                        func Max

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

                                                                                                                                                                                                                                                                          Max calculates per-element maximum of two arrays or an array and a scalar.

                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gacc40fa15eac0fb83f8ca70b7cc0b588d

                                                                                                                                                                                                                                                                          func MeanStdDev

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

                                                                                                                                                                                                                                                                            MeanStdDev calculates a mean and standard deviation of array elements.

                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga846c858f4004d59493d7c6a4354b301d

                                                                                                                                                                                                                                                                            func MedianBlur

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

                                                                                                                                                                                                                                                                              MedianBlur blurs an image using the median filter.

                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga564869aa33e58769b4469101aac458f9

                                                                                                                                                                                                                                                                              func Merge

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

                                                                                                                                                                                                                                                                                Merge creates one multi-channel array out of several single-channel ones.

                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga7d7b4d6c6ee504b30a20b1680029c7b4

                                                                                                                                                                                                                                                                                func Min

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

                                                                                                                                                                                                                                                                                  Min calculates per-element minimum of two arrays or an array and a scalar.

                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga9af368f182ee76d0463d0d8d5330b764

                                                                                                                                                                                                                                                                                  func MinEnclosingCircle

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

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

                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/3.4/d3/dc0/group__imgproc__shape.html#ga8ce13c24081bbc7151e9326f412190f1

                                                                                                                                                                                                                                                                                    func MinMaxIdx

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

                                                                                                                                                                                                                                                                                      MinMaxIdx finds the global minimum and maximum in an array.

                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga7622c466c628a75d9ed008b42250a73f

                                                                                                                                                                                                                                                                                      func MinMaxLoc

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

                                                                                                                                                                                                                                                                                        MinMaxLoc finds the global minimum and maximum in an array.

                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/trunk/d2/de8/group__core__array.html#gab473bf2eb6d14ff97e89b355dac20707

                                                                                                                                                                                                                                                                                        func MixChannels

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

                                                                                                                                                                                                                                                                                          Copies specified channels from input arrays to the specified channels of output arrays.

                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga51d768c270a1cdd3497255017c4504be

                                                                                                                                                                                                                                                                                          func Moments

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

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

                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#ga556a180f43cab22649c23ada36a8a139

                                                                                                                                                                                                                                                                                            func MorphologyEx

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

                                                                                                                                                                                                                                                                                              MorphologyEx performs advanced morphological transformations.

                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga67493776e3ad1a3df63883829375201f

                                                                                                                                                                                                                                                                                              func MorphologyExWithParams

                                                                                                                                                                                                                                                                                              func MorphologyExWithParams(src Mat, dst *Mat, op MorphType, kernel Mat, iterations int, borderType BorderType)

                                                                                                                                                                                                                                                                                                MorphologyExWithParams performs advanced morphological transformations.

                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga67493776e3ad1a3df63883829375201f

                                                                                                                                                                                                                                                                                                func MulSpectrums

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

                                                                                                                                                                                                                                                                                                  Mulspectrums performs the per-element multiplication of two Fourier spectrums.

                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga3ab38646463c59bf0ce962a9d51db64f

                                                                                                                                                                                                                                                                                                  func Multiply

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

                                                                                                                                                                                                                                                                                                    Multiply calculates the per-element scaled product of two arrays. Both input arrays must be of the same size and the same type.

                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga979d898a58d7f61c53003e162e7ad89f

                                                                                                                                                                                                                                                                                                    func MultiplyWithParams

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

                                                                                                                                                                                                                                                                                                      MultiplyWithParams calculates the per-element scaled product of two arrays. Both input arrays must be of the same size and the same type.

                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga979d898a58d7f61c53003e162e7ad89f

                                                                                                                                                                                                                                                                                                      func NMSBoxes

                                                                                                                                                                                                                                                                                                      func NMSBoxes(bboxes []image.Rectangle, scores []float32, scoreThreshold float32, nmsThreshold float32, indices []int)

                                                                                                                                                                                                                                                                                                        NMSBoxes performs non maximum suppression given boxes and corresponding scores.

                                                                                                                                                                                                                                                                                                        For futher details, please see: https://docs.opencv.org/4.4.0/d6/d0f/group__dnn.html#ga9d118d70a1659af729d01b10233213ee

                                                                                                                                                                                                                                                                                                        func NMSBoxesWithParams

                                                                                                                                                                                                                                                                                                        func NMSBoxesWithParams(bboxes []image.Rectangle, scores []float32, scoreThreshold float32, nmsThreshold float32, indices []int, eta float32, topK int)

                                                                                                                                                                                                                                                                                                          NMSBoxesWithParams performs non maximum suppression given boxes and corresponding scores.

                                                                                                                                                                                                                                                                                                          For futher details, please see: https://docs.opencv.org/4.4.0/d6/d0f/group__dnn.html#ga9d118d70a1659af729d01b10233213ee

                                                                                                                                                                                                                                                                                                          func Norm

                                                                                                                                                                                                                                                                                                          func Norm(src1 Mat, normType NormType) float64

                                                                                                                                                                                                                                                                                                            Norm calculates the absolute norm of an array.

                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga7c331fb8dd951707e184ef4e3f21dd33

                                                                                                                                                                                                                                                                                                            func NormWithMats

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

                                                                                                                                                                                                                                                                                                              Norm calculates the absolute difference/relative norm of two arrays.

                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga7c331fb8dd951707e184ef4e3f21dd33

                                                                                                                                                                                                                                                                                                              func Normalize

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

                                                                                                                                                                                                                                                                                                                Normalize normalizes the norm or value range of an array.

                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga87eef7ee3970f86906d69a92cbf064bd

                                                                                                                                                                                                                                                                                                                func OpenCVVersion

                                                                                                                                                                                                                                                                                                                func OpenCVVersion() string

                                                                                                                                                                                                                                                                                                                  OpenCVVersion returns the current OpenCV lib version

                                                                                                                                                                                                                                                                                                                  func PerspectiveTransform

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

                                                                                                                                                                                                                                                                                                                    PerspectiveTransform performs the perspective matrix transformation of vectors.

                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gad327659ac03e5fd6894b90025e6900a7

                                                                                                                                                                                                                                                                                                                    func Phase

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

                                                                                                                                                                                                                                                                                                                      Phase calculates the rotation angle of 2D vectors.

                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga9db9ca9b4d81c3bde5677b8f64dc0137

                                                                                                                                                                                                                                                                                                                      func PolarToCart

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

                                                                                                                                                                                                                                                                                                                        PolatToCart calculates x and y coordinates of 2D vectors from their magnitude and angle.

                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga581ff9d44201de2dd1b40a50db93d665

                                                                                                                                                                                                                                                                                                                        func Polylines

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

                                                                                                                                                                                                                                                                                                                          Polylines draws several polygonal curves.

                                                                                                                                                                                                                                                                                                                          For more information, see: https://docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#ga1ea127ffbbb7e0bfc4fd6fd2eb64263c

                                                                                                                                                                                                                                                                                                                          func Pow

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

                                                                                                                                                                                                                                                                                                                            Pow raises every array element to a power.

                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaf0d056b5bd1dc92500d6f6cf6bac41ef

                                                                                                                                                                                                                                                                                                                            func PutText

                                                                                                                                                                                                                                                                                                                            func PutText(img *Mat, text string, org image.Point, fontFace HersheyFont, fontScale float64, c color.RGBA, thickness int)

                                                                                                                                                                                                                                                                                                                              PutText 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.

                                                                                                                                                                                                                                                                                                                              For further details, please see: http://docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#ga5126f47f883d730f633d74f07456c576

                                                                                                                                                                                                                                                                                                                              func PutTextWithParams

                                                                                                                                                                                                                                                                                                                              func PutTextWithParams(img *Mat, text string, org image.Point, fontFace HersheyFont, fontScale float64, c color.RGBA, thickness int, lineType LineType, bottomLeftOrigin bool)

                                                                                                                                                                                                                                                                                                                                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.

                                                                                                                                                                                                                                                                                                                                For further details, please see: http://docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#ga5126f47f883d730f633d74f07456c576

                                                                                                                                                                                                                                                                                                                                func PyrDown

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

                                                                                                                                                                                                                                                                                                                                  PyrDown blurs an image and downsamples it.

                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gaf9bba239dfca11654cb7f50f889fc2ff

                                                                                                                                                                                                                                                                                                                                  func PyrUp

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

                                                                                                                                                                                                                                                                                                                                    PyrUp upsamples an image and then blurs it.

                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gada75b59bdaaca411ed6fee10085eb784

                                                                                                                                                                                                                                                                                                                                    func RandN

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

                                                                                                                                                                                                                                                                                                                                      RandN Fills the array with normally distributed random numbers.

                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaeff1f61e972d133a04ce3a5f81cf6808

                                                                                                                                                                                                                                                                                                                                      func RandShuffle

                                                                                                                                                                                                                                                                                                                                      func RandShuffle(mat *Mat)

                                                                                                                                                                                                                                                                                                                                        RandShuffle Shuffles the array elements randomly.

                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6a789c8a5cb56c6dd62506179808f763

                                                                                                                                                                                                                                                                                                                                        func RandShuffleWithParams

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

                                                                                                                                                                                                                                                                                                                                          RandShuffleWithParams Shuffles the array elements randomly.

                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6a789c8a5cb56c6dd62506179808f763

                                                                                                                                                                                                                                                                                                                                          func RandU

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

                                                                                                                                                                                                                                                                                                                                            RandU Generates a single uniformly-distributed random number or an array of random numbers.

                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga1ba1026dca0807b27057ba6a49d258c0

                                                                                                                                                                                                                                                                                                                                            func Rectangle

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

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

                                                                                                                                                                                                                                                                                                                                              For further details, please see: http://docs.opencv.org/master/d6/d6e/group__imgproc__draw.html#ga346ac30b5c74e9b5137576c9ee9e0e8c

                                                                                                                                                                                                                                                                                                                                              func Reduce

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

                                                                                                                                                                                                                                                                                                                                                Reduce reduces a matrix to a vector.

                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga4b78072a303f29d9031d56e5638da78e

                                                                                                                                                                                                                                                                                                                                                func Remap

                                                                                                                                                                                                                                                                                                                                                func Remap(src Mat, dst, map1, map2 *Mat, interpolation InterpolationFlags, borderMode BorderType, borderValue color.RGBA)

                                                                                                                                                                                                                                                                                                                                                  Remap applies a generic geometrical transformation to an image.

                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#gab75ef31ce5cdfb5c44b6da5f3b908ea4

                                                                                                                                                                                                                                                                                                                                                  func Repeat

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

                                                                                                                                                                                                                                                                                                                                                    Repeat fills the output array with repeated copies of the input array.

                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga496c3860f3ac44c40b48811333cfda2d

                                                                                                                                                                                                                                                                                                                                                    func Resize

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

                                                                                                                                                                                                                                                                                                                                                      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.

                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#ga47a974309e9102f5f08231edc7e7529d

                                                                                                                                                                                                                                                                                                                                                      func Rotate

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

                                                                                                                                                                                                                                                                                                                                                        Rotate rotates a 2D array in multiples of 90 degrees

                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga4ad01c0978b0ce64baa246811deeac24

                                                                                                                                                                                                                                                                                                                                                        func SVDCompute

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

                                                                                                                                                                                                                                                                                                                                                          SVDCompute decomposes matrix and stores the results to user-provided matrices

                                                                                                                                                                                                                                                                                                                                                          https://docs.opencv.org/4.1.2/df/df7/classcv_1_1SVD.html#a76f0b2044df458160292045a3d3714c6

                                                                                                                                                                                                                                                                                                                                                          func ScaleAdd

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

                                                                                                                                                                                                                                                                                                                                                            Calculates the sum of a scaled array and another array.

                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga9e0845db4135f55dcf20227402f00d98

                                                                                                                                                                                                                                                                                                                                                            func Scharr

                                                                                                                                                                                                                                                                                                                                                            func Scharr(src Mat, dst *Mat, dDepth MatType, dx int, dy int, scale float64,
                                                                                                                                                                                                                                                                                                                                                            	delta float64, borderType BorderType)

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

                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gaa13106761eedf14798f37aa2d60404c9

                                                                                                                                                                                                                                                                                                                                                              func SeamlessClone

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

                                                                                                                                                                                                                                                                                                                                                                SeamlessClone blend two image by Poisson Blending.

                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/df/da0/group__photo__clone.html#ga2bf426e4c93a6b1f21705513dfeca49d

                                                                                                                                                                                                                                                                                                                                                                func SelectROI

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

                                                                                                                                                                                                                                                                                                                                                                  Deprecated: use Window.SelectROI instead

                                                                                                                                                                                                                                                                                                                                                                  func SelectROIs

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

                                                                                                                                                                                                                                                                                                                                                                    Deprecated: use Window.SelectROIs instead

                                                                                                                                                                                                                                                                                                                                                                    func SepFilter2D

                                                                                                                                                                                                                                                                                                                                                                    func SepFilter2D(src Mat, dst *Mat, ddepth MatType, kernelX, kernelY Mat, anchor image.Point, delta float64, borderType BorderType)

                                                                                                                                                                                                                                                                                                                                                                      SepFilter2D applies a separable linear filter to the image.

                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga910e29ff7d7b105057d1625a4bf6318d

                                                                                                                                                                                                                                                                                                                                                                      func SetIdentity

                                                                                                                                                                                                                                                                                                                                                                      func SetIdentity(src Mat, scalar float64)

                                                                                                                                                                                                                                                                                                                                                                        SetIdentity initializes a scaled identity matrix. For further details, please see:

                                                                                                                                                                                                                                                                                                                                                                        https://docs.opencv.org/master/d2/de8/group__core__array.html#ga388d7575224a4a277ceb98ccaa327c99
                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                        func SetRNGSeed

                                                                                                                                                                                                                                                                                                                                                                        func SetRNGSeed(seed int)

                                                                                                                                                                                                                                                                                                                                                                          TheRNG Sets state of default random number generator.

                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga757e657c037410d9e19e819569e7de0f

                                                                                                                                                                                                                                                                                                                                                                          func Sobel

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

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

                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gacea54f142e81b6758cb6f375ce782c8d

                                                                                                                                                                                                                                                                                                                                                                            func Solve

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

                                                                                                                                                                                                                                                                                                                                                                              Solve solves one or more linear systems or least-squares problems.

                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga12b43690dbd31fed96f213eefead2373

                                                                                                                                                                                                                                                                                                                                                                              func SolveCubic

                                                                                                                                                                                                                                                                                                                                                                              func SolveCubic(coeffs Mat, roots *Mat) int

                                                                                                                                                                                                                                                                                                                                                                                SolveCubic finds the real roots of a cubic equation.

                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga1c3b0b925b085b6e96931ee309e6a1da

                                                                                                                                                                                                                                                                                                                                                                                func SolvePoly

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

                                                                                                                                                                                                                                                                                                                                                                                  SolvePoly finds the real or complex roots of a polynomial equation.

                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gac2f5e953016fabcdf793d762f4ec5dce

                                                                                                                                                                                                                                                                                                                                                                                  func Sort

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

                                                                                                                                                                                                                                                                                                                                                                                    Sort sorts each row or each column of a matrix.

                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga45dd56da289494ce874be2324856898f

                                                                                                                                                                                                                                                                                                                                                                                    func SortIdx

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

                                                                                                                                                                                                                                                                                                                                                                                      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

                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gadf35157cbf97f3cb85a545380e383506

                                                                                                                                                                                                                                                                                                                                                                                      func SpatialGradient

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

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

                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga405d03b20c782b65a4daf54d233239a2

                                                                                                                                                                                                                                                                                                                                                                                        func SqBoxFilter

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

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

                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga045028184a9ef65d7d2579e5c4bff6c0

                                                                                                                                                                                                                                                                                                                                                                                          func Subtract

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

                                                                                                                                                                                                                                                                                                                                                                                            Subtract calculates the per-element subtraction of two arrays or an array and a scalar.

                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaa0f00d98b4b5edeaeb7b8333b2de353b

                                                                                                                                                                                                                                                                                                                                                                                            func TextureFlattening

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

                                                                                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                                                                                              func Threshold

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

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

                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/3.3.0/d7/d1b/group__imgproc__misc.html#gae8a4a146d1ca78c626a53577199e9c57

                                                                                                                                                                                                                                                                                                                                                                                                func Transform

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

                                                                                                                                                                                                                                                                                                                                                                                                  Transform performs the matrix transformation of every array element.

                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga393164aa54bb9169ce0a8cc44e08ff22

                                                                                                                                                                                                                                                                                                                                                                                                  func Transpose

                                                                                                                                                                                                                                                                                                                                                                                                  func Transpose(src Mat, dst *Mat)

                                                                                                                                                                                                                                                                                                                                                                                                    Transpose transposes a matrix.

                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga46630ed6c0ea6254a35f447289bd7404

                                                                                                                                                                                                                                                                                                                                                                                                    func Undistort

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

                                                                                                                                                                                                                                                                                                                                                                                                    func UndistortPoints

                                                                                                                                                                                                                                                                                                                                                                                                    func UndistortPoints(src Mat, dst *Mat, cameraMatrix, distCoeffs, rectificationTransform, newCameraMatrix Mat)

                                                                                                                                                                                                                                                                                                                                                                                                      UndistortPoints transforms points to compensate for lens distortion

                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d9/d0c/group__calib3d.html#ga55c716492470bfe86b0ee9bf3a1f0f7e

                                                                                                                                                                                                                                                                                                                                                                                                      func Vconcat

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

                                                                                                                                                                                                                                                                                                                                                                                                        Vconcat applies vertical concatenation to given matrices.

                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaab5ceee39e0580f879df645a872c6bf7

                                                                                                                                                                                                                                                                                                                                                                                                        func Version

                                                                                                                                                                                                                                                                                                                                                                                                        func Version() string

                                                                                                                                                                                                                                                                                                                                                                                                          Version returns the current golang package version

                                                                                                                                                                                                                                                                                                                                                                                                          func WaitKey

                                                                                                                                                                                                                                                                                                                                                                                                          func WaitKey(delay int) int

                                                                                                                                                                                                                                                                                                                                                                                                            WaitKey that is not attached to a specific Window. Only use when no Window exists in your application, e.g. command line app.

                                                                                                                                                                                                                                                                                                                                                                                                            func WarpAffine

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

                                                                                                                                                                                                                                                                                                                                                                                                              WarpAffine applies an affine transformation to an image. For more parameters please check WarpAffineWithParams

                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#ga0203d9ee5fcd28d40dbc4a1ea4451983

                                                                                                                                                                                                                                                                                                                                                                                                              func WarpAffineWithParams

                                                                                                                                                                                                                                                                                                                                                                                                              func WarpAffineWithParams(src Mat, dst *Mat, m Mat, sz image.Point, flags InterpolationFlags, borderType BorderType, borderValue color.RGBA)

                                                                                                                                                                                                                                                                                                                                                                                                                WarpAffineWithParams applies an affine transformation to an image.

                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#ga0203d9ee5fcd28d40dbc4a1ea4451983

                                                                                                                                                                                                                                                                                                                                                                                                                func WarpPerspective

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

                                                                                                                                                                                                                                                                                                                                                                                                                  WarpPerspective applies a perspective transformation to an image.

                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#gaf73673a7e8e18ec6963e3774e6a94b87

                                                                                                                                                                                                                                                                                                                                                                                                                  func Watershed

                                                                                                                                                                                                                                                                                                                                                                                                                  func Watershed(image Mat, markers *Mat)

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

                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d7/d1b/group__imgproc__misc.html#ga3267243e4d3f95165d55a618c65ac6e1

                                                                                                                                                                                                                                                                                                                                                                                                                    Types

                                                                                                                                                                                                                                                                                                                                                                                                                    type AKAZE

                                                                                                                                                                                                                                                                                                                                                                                                                    type AKAZE struct {
                                                                                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                      AKAZE is a wrapper around the cv::AKAZE algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                      func NewAKAZE

                                                                                                                                                                                                                                                                                                                                                                                                                      func NewAKAZE() AKAZE

                                                                                                                                                                                                                                                                                                                                                                                                                        NewAKAZE returns a new AKAZE algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d8/d30/classcv_1_1AKAZE.html

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*AKAZE) Close

                                                                                                                                                                                                                                                                                                                                                                                                                        func (a *AKAZE) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                          Close AKAZE.

                                                                                                                                                                                                                                                                                                                                                                                                                          func (*AKAZE) Detect

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

                                                                                                                                                                                                                                                                                                                                                                                                                            Detect keypoints in an image using AKAZE.

                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#aa4e9a7082ec61ebc108806704fbd7887

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*AKAZE) DetectAndCompute

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

                                                                                                                                                                                                                                                                                                                                                                                                                              DetectAndCompute keypoints and compute in an image using AKAZE.

                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#a8be0d1c20b08eb867184b8d74c15a677

                                                                                                                                                                                                                                                                                                                                                                                                                              type AdaptiveThresholdType

                                                                                                                                                                                                                                                                                                                                                                                                                              type AdaptiveThresholdType int

                                                                                                                                                                                                                                                                                                                                                                                                                                AdaptiveThresholdType type of adaptive threshold operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                	// AdaptiveThresholdMean threshold type
                                                                                                                                                                                                                                                                                                                                                                                                                                	AdaptiveThresholdMean AdaptiveThresholdType = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                	// AdaptiveThresholdGaussian threshold type
                                                                                                                                                                                                                                                                                                                                                                                                                                	AdaptiveThresholdGaussian AdaptiveThresholdType = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                func (AdaptiveThresholdType) String

                                                                                                                                                                                                                                                                                                                                                                                                                                func (c AdaptiveThresholdType) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                type AgastFeatureDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                type AgastFeatureDetector struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                  AgastFeatureDetector is a wrapper around the cv::AgastFeatureDetector.

                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewAgastFeatureDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewAgastFeatureDetector() AgastFeatureDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                    NewAgastFeatureDetector returns a new AgastFeatureDetector algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d7/d19/classcv_1_1AgastFeatureDetector.html

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*AgastFeatureDetector) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (a *AgastFeatureDetector) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                      Close AgastFeatureDetector.

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*AgastFeatureDetector) Detect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                        Detect keypoints in an image using AgastFeatureDetector.

                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#aa4e9a7082ec61ebc108806704fbd7887

                                                                                                                                                                                                                                                                                                                                                                                                                                        type BFMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                        type BFMatcher struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                          BFMatcher is a wrapper around the the cv::BFMatcher algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewBFMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewBFMatcher() BFMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                            NewBFMatcher returns a new BFMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d3/da1/classcv_1_1BFMatcher.html#abe0bb11749b30d97f60d6ade665617bd

                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewBFMatcherWithParams

                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewBFMatcherWithParams(normType NormType, crossCheck bool) BFMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                              NewBFMatcherWithParams creates a new BFMatchers but allows setting parameters to values other than just the defaults.

                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d3/da1/classcv_1_1BFMatcher.html#abe0bb11749b30d97f60d6ade665617bd

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*BFMatcher) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (b *BFMatcher) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                Close BFMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*BFMatcher) KnnMatch

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                  KnnMatch Finds the k best matches for each descriptor from a query set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/db/d39/classcv_1_1DescriptorMatcher.html#aa880f9353cdf185ccf3013e08210483a

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type BRISK

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type BRISK struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                    BRISK is a wrapper around the cv::BRISK algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewBRISK

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewBRISK() BRISK

                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewBRISK returns a new BRISK algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d8/d30/classcv_1_1AKAZE.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*BRISK) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (b *BRISK) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Close BRISK.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*BRISK) Detect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Detect keypoints in an image using BRISK.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#aa4e9a7082ec61ebc108806704fbd7887

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*BRISK) DetectAndCompute

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                            DetectAndCompute keypoints and compute in an image using BRISK.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#a8be0d1c20b08eb867184b8d74c15a677

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type BackgroundSubtractorKNN

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type BackgroundSubtractorKNN struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                              BackgroundSubtractorKNN is a wrapper around the cv::BackgroundSubtractorKNN.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewBackgroundSubtractorKNN

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewBackgroundSubtractorKNN() BackgroundSubtractorKNN

                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewBackgroundSubtractorKNN returns a new BackgroundSubtractor algorithm of type KNN. K-Nearest Neighbors (KNN) uses a Background/Foreground Segmentation Algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/de/de1/group__video__motion.html#gac9be925771f805b6fdb614ec2292006d https://docs.opencv.org/master/db/d88/classcv_1_1BackgroundSubtractorKNN.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewBackgroundSubtractorKNNWithParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewBackgroundSubtractorKNNWithParams returns a new BackgroundSubtractor algorithm of type KNN with customized parameters. K-Nearest Neighbors (KNN) uses a Background/Foreground Segmentation Algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/de/de1/group__video__motion.html#gac9be925771f805b6fdb614ec2292006d https://docs.opencv.org/master/db/d88/classcv_1_1BackgroundSubtractorKNN.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*BackgroundSubtractorKNN) Apply

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Apply computes a foreground mask using the current BackgroundSubtractorKNN.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d7/df6/classcv_1_1BackgroundSubtractor.html#aa735e76f7069b3fa9c3f32395f9ccd21

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*BackgroundSubtractorKNN) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (k *BackgroundSubtractorKNN) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Close BackgroundSubtractorKNN.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type BackgroundSubtractorMOG2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type BackgroundSubtractorMOG2 struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        BackgroundSubtractorMOG2 is a wrapper around the cv::BackgroundSubtractorMOG2.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewBackgroundSubtractorMOG2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewBackgroundSubtractorMOG2() BackgroundSubtractorMOG2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewBackgroundSubtractorMOG2 returns a new BackgroundSubtractor algorithm of type MOG2. MOG2 is a Gaussian Mixture-based Background/Foreground Segmentation Algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/de/de1/group__video__motion.html#ga2beb2dee7a073809ccec60f145b6b29c https://docs.opencv.org/master/d7/d7b/classcv_1_1BackgroundSubtractorMOG2.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewBackgroundSubtractorMOG2WithParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewBackgroundSubtractorMOG2WithParams returns a new BackgroundSubtractor algorithm of type MOG2 with customized parameters. MOG2 is a Gaussian Mixture-based Background/Foreground Segmentation Algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/de/de1/group__video__motion.html#ga2beb2dee7a073809ccec60f145b6b29c https://docs.opencv.org/master/d7/d7b/classcv_1_1BackgroundSubtractorMOG2.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*BackgroundSubtractorMOG2) Apply

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Apply computes a foreground mask using the current BackgroundSubtractorMOG2.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d7/df6/classcv_1_1BackgroundSubtractor.html#aa735e76f7069b3fa9c3f32395f9ccd21

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*BackgroundSubtractorMOG2) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (b *BackgroundSubtractorMOG2) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Close BackgroundSubtractorMOG2.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type BorderType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type BorderType int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  BorderType type of border.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// BorderConstant border type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BorderConstant BorderType = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// BorderReplicate border type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BorderReplicate BorderType = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// BorderReflect border type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BorderReflect BorderType = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// BorderWrap border type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BorderWrap BorderType = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// BorderReflect101 border type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BorderReflect101 BorderType = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// BorderTransparent border type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BorderTransparent BorderType = 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// BorderDefault border type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BorderDefault = BorderReflect101
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// BorderIsolated border type
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BorderIsolated BorderType = 16
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (BorderType) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c BorderType) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CLAHE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CLAHE struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CLAHE is a wrapper around the cv::CLAHE algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewCLAHE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewCLAHE() CLAHE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewCLAHE returns a new CLAHE algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d6/db6/classcv_1_1CLAHE.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewCLAHEWithParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewCLAHEWithParams returns a new CLAHE algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d6/db6/classcv_1_1CLAHE.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*CLAHE) Apply

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Apply CLAHE.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d6/db6/classcv_1_1CLAHE.html#a4e92e0e427de21be8d1fae8dcd862c5e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*CLAHE) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c *CLAHE) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Close CLAHE.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CalibCBFlag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type CalibCBFlag int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CalibCBFlag value for chessboard calibration For more details, please see: https://docs.opencv.org/master/d9/d0c/group__calib3d.html#ga93efa9b0aa890de240ca32b11253dd4a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Various operation flags that can be zero or a combination of the following values:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//  Use adaptive thresholding to convert the image to black and white, rather than a fixed threshold level (computed from the average image brightness).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CalibCBAdaptiveThresh CalibCBFlag = 1 << iota
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//  Normalize the image gamma with equalizeHist before applying fixed or adaptive thresholding.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CalibCBNormalizeImage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//  Use additional criteria (like contour area, perimeter, square-like shape) to filter out false quads extracted at the contour retrieval stage.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CalibCBFilterQuads
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	//  Run a fast check on the image that looks for chessboard corners, and shortcut the call if none is found. This can drastically speed up the call in the degenerate condition when no chessboard is observed.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CalibCBFastCheck
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CalibCBExhaustive
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CalibCBAccuracy
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CalibCBLarger
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CalibCBMarker
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (CalibCBFlag) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c CalibCBFlag) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CalibFlag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CalibFlag int32

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CalibFlag value for calibration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CalibUseIntrinsicGuess indicates that cameraMatrix contains valid initial values
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// of fx, fy, cx, cy that are optimized further. Otherwise, (cx, cy) is initially
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// set to the image center ( imageSize is used), and focal distances are computed
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// in a least-squares fashion.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CalibUseIntrinsicGuess CalibFlag = 1 << iota
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CalibRecomputeExtrinsic indicates that extrinsic will be recomputed after each
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// iteration of intrinsic optimization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CalibRecomputeExtrinsic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CalibCheckCond indicates that the functions will check validity of condition number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CalibCheckCond
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CalibFixSkew indicates that skew coefficient (alpha) is set to zero and stay zero
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CalibFixSkew
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CalibFixK1 indicates that selected distortion coefficients are set to zeros and stay zero
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CalibFixK1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CalibFixK2 indicates that selected distortion coefficients are set to zeros and stay zero
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CalibFixK2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CalibFixK3 indicates that selected distortion coefficients are set to zeros and stay zero
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CalibFixK3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CalibFixK4 indicates that selected distortion coefficients are set to zeros and stay zero
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CalibFixK4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CalibFixIntrinsic indicates that fix K1, K2? and D1, D2? so that only R, T matrices are estimated
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CalibFixIntrinsic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// CalibFixPrincipalPoint indicates that the principal point is not changed during the global optimization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// It stays at the center or at a different location specified when CalibUseIntrinsicGuess is set too.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	CalibFixPrincipalPoint
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (CalibFlag) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c CalibFlag) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CascadeClassifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type CascadeClassifier struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CascadeClassifier is a cascade classifier class for object detection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: http://docs.opencv.org/master/d1/de5/classcv_1_1CascadeClassifier.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewCascadeClassifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewCascadeClassifier() CascadeClassifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewCascadeClassifier returns a new CascadeClassifier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*CascadeClassifier) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c *CascadeClassifier) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Close deletes the CascadeClassifier's pointer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*CascadeClassifier) DetectMultiScale

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DetectMultiScale detects objects of different sizes in the input Mat image. The detected objects are returned as a slice of image.Rectangle structs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: http://docs.opencv.org/master/d1/de5/classcv_1_1CascadeClassifier.html#aaf8181cb63968136476ec4204ffca498

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*CascadeClassifier) DetectMultiScaleWithParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DetectMultiScaleWithParams calls DetectMultiScale but allows setting parameters to values other than just the defaults.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: http://docs.opencv.org/master/d1/de5/classcv_1_1CascadeClassifier.html#aaf8181cb63968136476ec4204ffca498

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*CascadeClassifier) Load

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Load cascade classifier from a file.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: http://docs.opencv.org/master/d1/de5/classcv_1_1CascadeClassifier.html#a1a5884c8cc749422f9eb77c2471958bc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ColorConversionCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ColorConversionCode int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ColorConversionCode is a color conversion code used on Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: http://docs.opencv.org/master/d7/d1b/group__imgproc__misc.html#ga4e0972be5de079fed4e3a10e24ef5ef0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToBGRA adds alpha channel to BGR image.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToBGRA ColorConversionCode = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRAToBGR removes alpha channel from BGR image.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRAToBGR ColorConversionCode = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToRGBA converts from BGR to RGB with alpha channel.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToRGBA ColorConversionCode = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBAToBGR converts from RGB with alpha to BGR color space.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBAToBGR ColorConversionCode = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToRGB converts from BGR to RGB without alpha channel.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToRGB ColorConversionCode = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRAToRGBA converts from BGR with alpha channel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// to RGB with alpha channel.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRAToRGBA ColorConversionCode = 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToGray converts from BGR to grayscale.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToGray ColorConversionCode = 6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBToGray converts from RGB to grayscale.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToGray ColorConversionCode = 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorGrayToBGR converts from grayscale to BGR.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorGrayToBGR ColorConversionCode = 8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorGrayToBGRA converts from grayscale to BGR with alpha channel.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorGrayToBGRA ColorConversionCode = 9
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRAToGray converts from BGR with alpha channel to grayscale.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRAToGray ColorConversionCode = 10
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBAToGray converts from RGB with alpha channel to grayscale.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBAToGray ColorConversionCode = 11
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToBGR565 converts from BGR to BGR565 (16-bit images).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToBGR565 ColorConversionCode = 12
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBToBGR565 converts from RGB to BGR565 (16-bit images).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToBGR565 ColorConversionCode = 13
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGR565ToBGR converts from BGR565 (16-bit images) to BGR.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGR565ToBGR ColorConversionCode = 14
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGR565ToRGB converts from BGR565 (16-bit images) to RGB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGR565ToRGB ColorConversionCode = 15
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRAToBGR565 converts from BGRA (with alpha channel)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// to BGR565 (16-bit images).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRAToBGR565 ColorConversionCode = 16
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBAToBGR565 converts from RGBA (with alpha channel)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// to BGR565 (16-bit images).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBAToBGR565 ColorConversionCode = 17
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGR565ToBGRA converts from BGR565 (16-bit images)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// to BGRA (with alpha channel).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGR565ToBGRA ColorConversionCode = 18
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGR565ToRGBA converts from BGR565 (16-bit images)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// to RGBA (with alpha channel).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGR565ToRGBA ColorConversionCode = 19
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorGrayToBGR565 converts from grayscale
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// to BGR565 (16-bit images).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorGrayToBGR565 ColorConversionCode = 20
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGR565ToGray converts from BGR565 (16-bit images)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// to grayscale.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGR565ToGray ColorConversionCode = 21
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToBGR555 converts from BGR to BGR555 (16-bit images).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToBGR555 ColorConversionCode = 22
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBToBGR555 converts from RGB to BGR555 (16-bit images).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToBGR555 ColorConversionCode = 23
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGR555ToBGR converts from BGR555 (16-bit images) to BGR.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGR555ToBGR ColorConversionCode = 24
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGR555ToRGB converts from BGR555 (16-bit images) to RGB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGR555ToRGB ColorConversionCode = 25
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRAToBGR555 converts from BGRA (with alpha channel)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// to BGR555 (16-bit images).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRAToBGR555 ColorConversionCode = 26
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBAToBGR555 converts from RGBA (with alpha channel)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// to BGR555 (16-bit images).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBAToBGR555 ColorConversionCode = 27
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGR555ToBGRA converts from BGR555 (16-bit images)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// to BGRA (with alpha channel).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGR555ToBGRA ColorConversionCode = 28
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGR555ToRGBA converts from BGR555 (16-bit images)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// to RGBA (with alpha channel).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGR555ToRGBA ColorConversionCode = 29
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorGrayToBGR555 converts from grayscale to BGR555 (16-bit images).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorGrayToBGR555 ColorConversionCode = 30
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGR555ToGRAY converts from BGR555 (16-bit images) to grayscale.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGR555ToGRAY ColorConversionCode = 31
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToXYZ converts from BGR to CIE XYZ.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToXYZ ColorConversionCode = 32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBToXYZ converts from RGB to CIE XYZ.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToXYZ ColorConversionCode = 33
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorXYZToBGR converts from CIE XYZ to BGR.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorXYZToBGR ColorConversionCode = 34
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorXYZToRGB converts from CIE XYZ to RGB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorXYZToRGB ColorConversionCode = 35
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToYCrCb converts from BGR to luma-chroma (aka YCC).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToYCrCb ColorConversionCode = 36
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBToYCrCb converts from RGB to luma-chroma (aka YCC).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToYCrCb ColorConversionCode = 37
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorYCrCbToBGR converts from luma-chroma (aka YCC) to BGR.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYCrCbToBGR ColorConversionCode = 38
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorYCrCbToRGB converts from luma-chroma (aka YCC) to RGB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYCrCbToRGB ColorConversionCode = 39
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToHSV converts from BGR to HSV (hue saturation value).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToHSV ColorConversionCode = 40
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBToHSV converts from RGB to HSV (hue saturation value).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToHSV ColorConversionCode = 41
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToLab converts from BGR to CIE Lab.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToLab ColorConversionCode = 44
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBToLab converts from RGB to CIE Lab.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToLab ColorConversionCode = 45
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToLuv converts from BGR to CIE Luv.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToLuv ColorConversionCode = 50
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBToLuv converts from RGB to CIE Luv.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToLuv ColorConversionCode = 51
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToHLS converts from BGR to HLS (hue lightness saturation).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToHLS ColorConversionCode = 52
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBToHLS converts from RGB to HLS (hue lightness saturation).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToHLS ColorConversionCode = 53
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorHSVToBGR converts from HSV (hue saturation value) to BGR.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorHSVToBGR ColorConversionCode = 54
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorHSVToRGB converts from HSV (hue saturation value) to RGB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorHSVToRGB ColorConversionCode = 55
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorLabToBGR converts from CIE Lab to BGR.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorLabToBGR ColorConversionCode = 56
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorLabToRGB converts from CIE Lab to RGB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorLabToRGB ColorConversionCode = 57
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorLuvToBGR converts from CIE Luv to BGR.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorLuvToBGR ColorConversionCode = 58
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorLuvToRGB converts from CIE Luv to RGB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorLuvToRGB ColorConversionCode = 59
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorHLSToBGR converts from HLS (hue lightness saturation) to BGR.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorHLSToBGR ColorConversionCode = 60
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorHLSToRGB converts from HLS (hue lightness saturation) to RGB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorHLSToRGB ColorConversionCode = 61
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToHSVFull converts from BGR to HSV (hue saturation value) full.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToHSVFull ColorConversionCode = 66
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBToHSVFull converts from RGB to HSV (hue saturation value) full.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToHSVFull ColorConversionCode = 67
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToHLSFull converts from BGR to HLS (hue lightness saturation) full.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToHLSFull ColorConversionCode = 68
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBToHLSFull converts from RGB to HLS (hue lightness saturation) full.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToHLSFull ColorConversionCode = 69
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorHSVToBGRFull converts from HSV (hue saturation value) to BGR full.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorHSVToBGRFull ColorConversionCode = 70
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorHSVToRGBFull converts from HSV (hue saturation value) to RGB full.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorHSVToRGBFull ColorConversionCode = 71
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorHLSToBGRFull converts from HLS (hue lightness saturation) to BGR full.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorHLSToBGRFull ColorConversionCode = 72
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorHLSToRGBFull converts from HLS (hue lightness saturation) to RGB full.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorHLSToRGBFull ColorConversionCode = 73
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorLBGRToLab converts from LBGR to CIE Lab.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorLBGRToLab ColorConversionCode = 74
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorLRGBToLab converts from LRGB to CIE Lab.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorLRGBToLab ColorConversionCode = 75
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorLBGRToLuv converts from LBGR to CIE Luv.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorLBGRToLuv ColorConversionCode = 76
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorLRGBToLuv converts from LRGB to CIE Luv.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorLRGBToLuv ColorConversionCode = 77
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorLabToLBGR converts from CIE Lab to LBGR.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorLabToLBGR ColorConversionCode = 78
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorLabToLRGB converts from CIE Lab to LRGB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorLabToLRGB ColorConversionCode = 79
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorLuvToLBGR converts from CIE Luv to LBGR.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorLuvToLBGR ColorConversionCode = 80
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorLuvToLRGB converts from CIE Luv to LRGB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorLuvToLRGB ColorConversionCode = 81
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorBGRToYUV converts from BGR to YUV.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToYUV ColorConversionCode = 82
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorRGBToYUV converts from RGB to YUV.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToYUV ColorConversionCode = 83
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorYUVToBGR converts from YUV to BGR.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGR ColorConversionCode = 84
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorYUVToRGB converts from YUV to RGB.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGB ColorConversionCode = 85
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorYUVToRGBNV12 converts from YUV 4:2:0 to RGB NV12.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBNV12 ColorConversionCode = 90
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorYUVToBGRNV12 converts from YUV 4:2:0 to BGR NV12.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRNV12 ColorConversionCode = 91
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorYUVToRGBNV21 converts from YUV 4:2:0 to RGB NV21.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBNV21 ColorConversionCode = 92
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorYUVToBGRNV21 converts from YUV 4:2:0 to BGR NV21.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRNV21 ColorConversionCode = 93
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorYUVToRGBANV12 converts from YUV 4:2:0 to RGBA NV12.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBANV12 ColorConversionCode = 94
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorYUVToBGRANV12 converts from YUV 4:2:0 to BGRA NV12.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRANV12 ColorConversionCode = 95
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorYUVToRGBANV21 converts from YUV 4:2:0 to RGBA NV21.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBANV21 ColorConversionCode = 96
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// ColorYUVToBGRANV21 converts from YUV 4:2:0 to BGRA NV21.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRANV21 ColorConversionCode = 97
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBYV12 ColorConversionCode = 98
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRYV12 ColorConversionCode = 99
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBIYUV ColorConversionCode = 100
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRIYUV ColorConversionCode = 101
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBAYV12 ColorConversionCode = 102
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRAYV12 ColorConversionCode = 103
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBAIYUV ColorConversionCode = 104
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRAIYUV ColorConversionCode = 105
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToGRAY420 ColorConversionCode = 106
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// YUV 4:2:2 family to RGB
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBUYVY ColorConversionCode = 107
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRUYVY ColorConversionCode = 108
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBAUYVY ColorConversionCode = 111
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRAUYVY ColorConversionCode = 112
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBYUY2 ColorConversionCode = 115
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRYUY2 ColorConversionCode = 116
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBYVYU ColorConversionCode = 117
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRYVYU ColorConversionCode = 118
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBAYUY2 ColorConversionCode = 119
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRAYUY2 ColorConversionCode = 120
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToRGBAYVYU ColorConversionCode = 121
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToBGRAYVYU ColorConversionCode = 122
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToGRAYUYVY ColorConversionCode = 123
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorYUVToGRAYYUY2 ColorConversionCode = 124
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// alpha premultiplication
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBATomRGBA ColorConversionCode = 125
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColormRGBAToRGBA ColorConversionCode = 126
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// RGB to YUV 4:2:0 family
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToYUVI420 ColorConversionCode = 127
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToYUVI420 ColorConversionCode = 128
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBAToYUVI420 ColorConversionCode = 129
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRAToYUVI420 ColorConversionCode = 130
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBToYUVYV12  ColorConversionCode = 131
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRToYUVYV12  ColorConversionCode = 132
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorRGBAToYUVYV12 ColorConversionCode = 133
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBGRAToYUVYV12 ColorConversionCode = 134
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Demosaicing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerBGToBGR ColorConversionCode = 46
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerGBToBGR ColorConversionCode = 47
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerRGToBGR ColorConversionCode = 48
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerGRToBGR ColorConversionCode = 49
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerBGToGRAY ColorConversionCode = 86
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerGBToGRAY ColorConversionCode = 87
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerRGToGRAY ColorConversionCode = 88
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerGRToGRAY ColorConversionCode = 89
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Demosaicing using Variable Number of Gradients
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerBGToBGRVNG ColorConversionCode = 62
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerGBToBGRVNG ColorConversionCode = 63
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerRGToBGRVNG ColorConversionCode = 64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerGRToBGRVNG ColorConversionCode = 65
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Edge-Aware Demosaicing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerBGToBGREA ColorConversionCode = 135
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerGBToBGREA ColorConversionCode = 136
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerRGToBGREA ColorConversionCode = 137
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerGRToBGREA ColorConversionCode = 138
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Demosaicing with alpha channel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerBGToBGRA ColorConversionCode = 139
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerGBToBGRA ColorConversionCode = 140
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerRGToBGRA ColorConversionCode = 141
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorBayerGRToBGRA ColorConversionCode = 142
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ColorCOLORCVTMAX ColorConversionCode = 143
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (ColorConversionCode) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c ColorConversionCode) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ColormapTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ColormapTypes int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ColormapTypes are the 12 GNU Octave/MATLAB equivalent colormaps.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d3/d50/group__imgproc__colormap.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapAutumn  ColormapTypes = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapBone    ColormapTypes = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapJet     ColormapTypes = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapWinter  ColormapTypes = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapRainbow ColormapTypes = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapOcean   ColormapTypes = 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapSummer  ColormapTypes = 6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapSpring  ColormapTypes = 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapCool    ColormapTypes = 8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapHsv     ColormapTypes = 9
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapPink    ColormapTypes = 10
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapHot     ColormapTypes = 11
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ColormapParula  ColormapTypes = 12
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  List of the available color maps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d3/d50/group__imgproc__colormap.html#ga9a805d8262bcbe273f16be9ea2055a65

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (ColormapTypes) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (c ColormapTypes) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CompareType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type CompareType int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CompareType is used for Compare operations to indicate which kind of comparison to use.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// CompareEQ src1 is equal to src2.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CompareEQ CompareType = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// CompareGT src1 is greater than src2.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CompareGT CompareType = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// CompareGE src1 is greater than or equal to src2.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CompareGE CompareType = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// CompareLT src1 is less than src2.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CompareLT CompareType = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// CompareLE src1 is less than or equal to src2.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CompareLE CompareType = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// CompareNE src1 is unequal to src2.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	CompareNE CompareType = 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (CompareType) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c CompareType) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ConnectedComponentsAlgorithmType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ConnectedComponentsAlgorithmType int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ConnectedComponentsAlgorithmType specifies the type for ConnectedComponents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// SAUF algorithm for 8-way connectivity, SAUF algorithm for 4-way connectivity.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	CCL_WU ConnectedComponentsAlgorithmType = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// BBDT algorithm for 8-way connectivity, SAUF algorithm for 4-way connectivity.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	CCL_DEFAULT ConnectedComponentsAlgorithmType = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// BBDT algorithm for 8-way connectivity, SAUF algorithm for 4-way connectivity
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	CCL_GRANA ConnectedComponentsAlgorithmType = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (ConnectedComponentsAlgorithmType) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ConnectedComponentsTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ConnectedComponentsTypes int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ConnectedComponentsTypes are the connected components algorithm output formats

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//The leftmost (x) coordinate which is the inclusive start of the bounding box in the horizontal direction.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CC_STAT_LEFT ConnectedComponentsTypes = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	//The topmost (y) coordinate which is the inclusive start of the bounding box in the vertical direction.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CC_STAT_TOP ConnectedComponentsTypes = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The horizontal size of the bounding box.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CC_STAT_WIDTH ConnectedComponentsTypes = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The vertical size of the bounding box.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CC_STAT_HEIGHT ConnectedComponentsTypes = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// The total area (in pixels) of the connected component.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CC_STAT_AREA ConnectedComponentsTypes = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CC_STAT_MAX ConnectedComponentsTypes = 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (ConnectedComponentsTypes) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c ConnectedComponentsTypes) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ContourApproximationMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ContourApproximationMode int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ContourApproximationMode is the mode of the contour approximation algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// ChainApproxNone stores absolutely all the contour points. That is,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// any 2 subsequent points (x1,y1) and (x2,y2) of the contour will be
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// either horizontal, vertical or diagonal neighbors, that is,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// max(abs(x1-x2),abs(y2-y1))==1.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ChainApproxNone ContourApproximationMode = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// ChainApproxSimple compresses horizontal, vertical, and diagonal segments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// and leaves only their end points.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// For example, an up-right rectangular contour is encoded with 4 points.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ChainApproxSimple ContourApproximationMode = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// ChainApproxTC89L1 applies one of the flavors of the Teh-Chin chain
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// approximation algorithms.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ChainApproxTC89L1 ContourApproximationMode = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// ChainApproxTC89KCOS applies one of the flavors of the Teh-Chin chain
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// approximation algorithms.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ChainApproxTC89KCOS ContourApproximationMode = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (ContourApproximationMode) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c ContourApproximationMode) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CovarFlags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type CovarFlags int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CovarFlags are the covariation flags used by functions such as BorderInterpolate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d0/de1/group__core.html#ga719ebd4a73f30f4fab258ab7616d0f0f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// CovarScrambled indicates to scramble the results.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CovarScrambled CovarFlags = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// CovarNormal indicates to use normal covariation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CovarNormal CovarFlags = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// CovarUseAvg indicates to use average covariation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CovarUseAvg CovarFlags = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// CovarScale indicates to use scaled covariation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CovarScale CovarFlags = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// CovarRows indicates to use covariation on rows.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CovarRows CovarFlags = 8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// CovarCols indicates to use covariation on columns.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	CovarCols CovarFlags = 16
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (CovarFlags) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (c CovarFlags) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DMatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type DMatch struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	QueryIdx int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	TrainIdx int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ImgIdx   int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Distance float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DMatch is data structure for matching keypoint descriptors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d4/de0/classcv_1_1DMatch.html#a546ddb9a87898f06e510e015a6de596e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DftFlags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type DftFlags int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DftFlags represents a DFT or DCT flag.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gaf4dde112b483b38175621befedda1f1c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DftForward performs forward 1D or 2D dft or dct.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DftForward DftFlags = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DftInverse performs an inverse 1D or 2D transform.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DftInverse DftFlags = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DftScale scales the result: divide it by the number of array elements. Normally, it is combined with DFT_INVERSE.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DftScale DftFlags = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DftRows performs a forward or inverse transform of every individual row of the input matrix.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DftRows DftFlags = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DftComplexOutput performs a forward transformation of 1D or 2D real array; the result, though being a complex array, has complex-conjugate symmetry
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DftComplexOutput DftFlags = 16
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DftRealOutput performs an inverse transformation of a 1D or 2D complex array; the result is normally a complex array of the same size,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// however, if the input array has conjugate-complex symmetry (for example, it is a result of forward transformation with DFT_COMPLEX_OUTPUT flag),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// the output is a real array.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DftRealOutput DftFlags = 32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DftComplexInput specifies that input is complex input. If this flag is set, the input must have 2 channels.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DftComplexInput DftFlags = 64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DctInverse performs an inverse 1D or 2D dct transform.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DctInverse = DftInverse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// DctRows performs a forward or inverse dct transform of every individual row of the input matrix.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	DctRows = DftRows
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (DftFlags) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c DftFlags) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DistanceTransformLabelTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type DistanceTransformLabelTypes int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DistanceTransformLabelTypes are the types of the DistanceTransform algorithm flag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// DistanceLabelCComp assigns the same label to each connected component of zeros in the source image
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// (as well as all the non-zero pixels closest to the connected component).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	DistanceLabelCComp DistanceTransformLabelTypes = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// DistanceLabelPixel assigns its own label to each zero pixel (and all the non-zero pixels closest to it).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	DistanceLabelPixel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (DistanceTransformLabelTypes) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DistanceTransformMasks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type DistanceTransformMasks int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DistanceTransformMasks are the marsk sizes for distance transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// DistanceMask3 is a mask of size 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	DistanceMask3 DistanceTransformMasks = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// DistanceMask5 is a mask of size 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	DistanceMask5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// DistanceMaskPrecise is not currently supported
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	DistanceMaskPrecise
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (DistanceTransformMasks) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c DistanceTransformMasks) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DistanceTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type DistanceTypes int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DistanceTypes types for Distance Transform and M-estimatorss

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d7/d1b/group__imgproc__misc.html#gaa2bfbebbc5c320526897996aafa1d8eb

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DistUser   DistanceTypes = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DistL1     DistanceTypes = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DistL2     DistanceTypes = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DistC      DistanceTypes = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DistL12    DistanceTypes = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DistFair   DistanceTypes = 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DistWelsch DistanceTypes = 6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	DistHuber  DistanceTypes = 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (DistanceTypes) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c DistanceTypes) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DrawMatchesFlag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type DrawMatchesFlag int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DrawMatchesFlag are the flags setting drawing feature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details please see: https://docs.opencv.org/master/de/d30/structcv_1_1DrawMatchesFlags.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// DrawDefault creates new image and for each keypoint only the center point will be drawn
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	DrawDefault DrawMatchesFlag = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// DrawOverOutImg draws matches on existing content of image
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	DrawOverOutImg DrawMatchesFlag = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// NotDrawSinglePoints will not draw single points
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	NotDrawSinglePoints DrawMatchesFlag = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// DrawRichKeyPoints draws the circle around each keypoint with keypoint size and orientation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	DrawRichKeyPoints DrawMatchesFlag = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (DrawMatchesFlag) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c DrawMatchesFlag) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FastFeatureDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type FastFeatureDetector struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          FastFeatureDetector is a wrapper around the cv::FastFeatureDetector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewFastFeatureDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewFastFeatureDetector() FastFeatureDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewFastFeatureDetector returns a new FastFeatureDetector algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/df/d74/classcv_1_1FastFeatureDetector.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewFastFeatureDetectorWithParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewFastFeatureDetectorWithParams returns a new FastFeatureDetector algorithm with parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/df/d74/classcv_1_1FastFeatureDetector.html#ab986f2ff8f8778aab1707e2642bc7f8e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*FastFeatureDetector) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (f *FastFeatureDetector) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Close FastFeatureDetector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*FastFeatureDetector) Detect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Detect keypoints in an image using FastFeatureDetector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#aa4e9a7082ec61ebc108806704fbd7887

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FastFeatureDetectorType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type FastFeatureDetectorType int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FastFeatureDetectorType defines the detector type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/df/d74/classcv_1_1FastFeatureDetector.html#a4654f6fb0aa4b8e9123b223bfa0e2a08

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//FastFeatureDetectorType58 is an alias of FastFeatureDetector::TYPE_5_8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FastFeatureDetectorType58 FastFeatureDetectorType = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//FastFeatureDetectorType712 is an alias of FastFeatureDetector::TYPE_7_12
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FastFeatureDetectorType712 FastFeatureDetectorType = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	//FastFeatureDetectorType916 is an alias of FastFeatureDetector::TYPE_9_16
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	FastFeatureDetectorType916 FastFeatureDetectorType = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (FastFeatureDetectorType) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (c FastFeatureDetectorType) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FileExt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type FileExt string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FileExt represents a file extension.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// PNGFileExt is the file extension for PNG.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	PNGFileExt FileExt = ".png"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// JPEGFileExt is the file extension for JPEG.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	JPEGFileExt FileExt = ".jpg"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// GIFFileExt is the file extension for GIF.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	GIFFileExt FileExt = ".gif"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FlannBasedMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type FlannBasedMatcher struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        FlannBasedMatcher is a wrapper around the the cv::FlannBasedMatcher algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewFlannBasedMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewFlannBasedMatcher() FlannBasedMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewFlannBasedMatcher returns a new FlannBasedMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/dc/de2/classcv_1_1FlannBasedMatcher.html#ab9114a6471e364ad221f89068ca21382

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*FlannBasedMatcher) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (f *FlannBasedMatcher) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Close FlannBasedMatcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*FlannBasedMatcher) KnnMatch

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              KnnMatch Finds the k best matches for each descriptor from a query set.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/db/d39/classcv_1_1DescriptorMatcher.html#aa880f9353cdf185ccf3013e08210483a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GFTTDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type GFTTDetector struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GFTTDetector is a wrapper around the cv::GFTTDetector algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewGFTTDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewGFTTDetector() GFTTDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewGFTTDetector returns a new GFTTDetector algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/df/d21/classcv_1_1GFTTDetector.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*GFTTDetector) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (a *GFTTDetector) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Close GFTTDetector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*GFTTDetector) Detect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Detect keypoints in an image using GFTTDetector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#aa4e9a7082ec61ebc108806704fbd7887

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GrabCutMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type GrabCutMode int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GrabCutMode is the flag for GrabCut algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// GCInitWithRect makes the function initialize the state and the mask using the provided rectangle.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// After that it runs the itercount iterations of the algorithm.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GCInitWithRect GrabCutMode = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// GCInitWithMask makes the function initialize the state using the provided mask.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// GCInitWithMask and GCInitWithRect can be combined.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Then all the pixels outside of the ROI are automatically initialized with GC_BGD.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GCInitWithMask GrabCutMode = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// GCEval means that the algorithm should just resume.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GCEval GrabCutMode = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// GCEvalFreezeModel means that the algorithm should just run a single iteration of the GrabCut algorithm
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// with the fixed model
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GCEvalFreezeModel GrabCutMode = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (GrabCutMode) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c GrabCutMode) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HOGDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HOGDescriptor struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          HOGDescriptor is a Histogram Of Gradiants (HOG) for object detection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d5/d33/structcv_1_1HOGDescriptor.html#a723b95b709cfd3f95cf9e616de988fc8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewHOGDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewHOGDescriptor() HOGDescriptor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewHOGDescriptor returns a new HOGDescriptor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*HOGDescriptor) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (h *HOGDescriptor) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Close deletes the HOGDescriptor's pointer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*HOGDescriptor) DetectMultiScale

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DetectMultiScale detects objects in the input Mat image. The detected objects are returned as a slice of image.Rectangle structs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d5/d33/structcv_1_1HOGDescriptor.html#a660e5cd036fd5ddf0f5767b352acd948

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*HOGDescriptor) DetectMultiScaleWithParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DetectMultiScaleWithParams calls DetectMultiScale but allows setting parameters to values other than just the defaults.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d5/d33/structcv_1_1HOGDescriptor.html#a660e5cd036fd5ddf0f5767b352acd948

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*HOGDescriptor) SetSVMDetector

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetSVMDetector sets the data for the HOGDescriptor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d5/d33/structcv_1_1HOGDescriptor.html#a09e354ad701f56f9c550dc0385dc36f1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HersheyFont

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type HersheyFont int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HersheyFont are the font libraries included in OpenCV. Only a subset of the available Hershey fonts are supported by OpenCV.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For more information, see: http://sources.isc.org/utils/misc/hershey-font.txt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// FontHersheySimplex is normal size sans-serif font.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FontHersheySimplex HersheyFont = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// FontHersheyPlain issmall size sans-serif font.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FontHersheyPlain HersheyFont = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// FontHersheyDuplex normal size sans-serif font
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// (more complex than FontHersheySIMPLEX).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FontHersheyDuplex HersheyFont = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// FontHersheyComplex i a normal size serif font.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FontHersheyComplex HersheyFont = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// FontHersheyTriplex is a normal size serif font
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// (more complex than FontHersheyCOMPLEX).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FontHersheyTriplex HersheyFont = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// FontHersheyComplexSmall is a smaller version of FontHersheyCOMPLEX.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FontHersheyComplexSmall HersheyFont = 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// FontHersheyScriptSimplex is a hand-writing style font.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FontHersheyScriptSimplex HersheyFont = 6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// FontHersheyScriptComplex is a more complex variant of FontHersheyScriptSimplex.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FontHersheyScriptComplex HersheyFont = 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// FontItalic is the flag for italic font.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	FontItalic HersheyFont = 16
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (HersheyFont) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (c HersheyFont) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HistCompMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type HistCompMethod int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        HistCompMethod is the method for Histogram comparison For more information, see https://docs.opencv.org/master/d6/dc7/group__imgproc__hist.html#ga994f53817d621e2e4228fc646342d386

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// HistCmpCorrel calculates the Correlation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HistCmpCorrel HistCompMethod = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// HistCmpChiSqr calculates the Chi-Square
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HistCmpChiSqr HistCompMethod = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// HistCmpIntersect calculates the Intersection
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HistCmpIntersect HistCompMethod = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// HistCmpBhattacharya applies the HistCmpBhattacharya by calculating the Bhattacharya distance.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HistCmpBhattacharya HistCompMethod = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// HistCmpHellinger applies the HistCmpBhattacharya comparison. It is a synonym to HistCmpBhattacharya.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HistCmpHellinger = HistCmpBhattacharya
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// HistCmpChiSqrAlt applies the Alternative Chi-Square (regularly used for texture comparsion).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HistCmpChiSqrAlt HistCompMethod = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// HistCmpKlDiv applies the Kullback-Liebler divergence comparison.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HistCmpKlDiv HistCompMethod = 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (HistCompMethod) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c HistCompMethod) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HomographyMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HomographyMethod int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HomograpyMethodAllPoints HomographyMethod = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HomograpyMethodLMEDS     HomographyMethod = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HomograpyMethodRANSAC    HomographyMethod = 8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HoughMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type HoughMode int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          HoughMode is the type for Hough transform variants.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// HoughStandard is the classical or standard Hough transform.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HoughStandard HoughMode = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// HoughProbabilistic is the probabilistic Hough transform (more efficient
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// in case if the picture contains a few long linear segments).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HoughProbabilistic HoughMode = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// HoughMultiScale is the multi-scale variant of the classical Hough
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// transform.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HoughMultiScale HoughMode = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// HoughGradient is basically 21HT, described in: HK Yuen, John Princen,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// John Illingworth, and Josef Kittler. Comparative study of hough
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// transform methods for circle finding. Image and Vision Computing,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// 8(1):71–77, 1990.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	HoughGradient HoughMode = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (HoughMode) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c HoughMode) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IMReadFlag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type IMReadFlag int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            IMReadFlag is one of the valid flags to use for the IMRead function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadUnchanged return the loaded image as is (with alpha channel,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// otherwise it gets cropped).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadUnchanged IMReadFlag = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadGrayScale always convert image to the single channel
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// grayscale image.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadGrayScale IMReadFlag = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadColor always converts image to the 3 channel BGR color image.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadColor IMReadFlag = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadAnyDepth returns 16-bit/32-bit image when the input has the corresponding
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// depth, otherwise convert it to 8-bit.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadAnyDepth IMReadFlag = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadAnyColor the image is read in any possible color format.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadAnyColor IMReadFlag = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadLoadGDAL uses the gdal driver for loading the image.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadLoadGDAL IMReadFlag = 8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadReducedGrayscale2 always converts image to the single channel grayscale image
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// and the image size reduced 1/2.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadReducedGrayscale2 IMReadFlag = 16
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadReducedColor2 always converts image to the 3 channel BGR color image and the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// image size reduced 1/2.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadReducedColor2 IMReadFlag = 17
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadReducedGrayscale4 always converts image to the single channel grayscale image and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// the image size reduced 1/4.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadReducedGrayscale4 IMReadFlag = 32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadReducedColor4 always converts image to the 3 channel BGR color image and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// the image size reduced 1/4.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadReducedColor4 IMReadFlag = 33
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadReducedGrayscale8 always convert image to the single channel grayscale image and
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// the image size reduced 1/8.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadReducedGrayscale8 IMReadFlag = 64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadReducedColor8 always convert image to the 3 channel BGR color image and the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// image size reduced 1/8.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadReducedColor8 IMReadFlag = 65
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// IMReadIgnoreOrientation do not rotate the image according to EXIF's orientation flag.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	IMReadIgnoreOrientation IMReadFlag = 128
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InterpolationFlags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InterpolationFlags int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              InterpolationFlags are bit flags that control the interpolation algorithm that is used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// InterpolationNearestNeighbor is nearest neighbor. (fast but low quality)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InterpolationNearestNeighbor InterpolationFlags = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// InterpolationLinear is bilinear interpolation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InterpolationLinear InterpolationFlags = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// InterpolationCubic is bicube interpolation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InterpolationCubic InterpolationFlags = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// InterpolationArea uses pixel area relation. It is preferred for image
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// decimation as it gives moire-free results.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InterpolationArea InterpolationFlags = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// InterpolationLanczos4 is Lanczos interpolation over 8x8 neighborhood.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InterpolationLanczos4 InterpolationFlags = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// InterpolationDefault is an alias for InterpolationLinear.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InterpolationDefault = InterpolationLinear
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// InterpolationMax indicates use maximum interpolation.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InterpolationMax InterpolationFlags = 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (InterpolationFlags) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c InterpolationFlags) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type KAZE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type KAZE struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                KAZE is a wrapper around the cv::KAZE algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewKAZE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewKAZE() KAZE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewKAZE returns a new KAZE algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d3/d61/classcv_1_1KAZE.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*KAZE) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (a *KAZE) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Close KAZE.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*KAZE) Detect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Detect keypoints in an image using KAZE.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#aa4e9a7082ec61ebc108806704fbd7887

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*KAZE) DetectAndCompute

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DetectAndCompute keypoints and compute in an image using KAZE.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#a8be0d1c20b08eb867184b8d74c15a677

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type KMeansFlags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type KMeansFlags int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          KMeansFlags for kmeans center selection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d0/de1/group__core.html#ga276000efe55ee2756e0c471c7b270949

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// KMeansRandomCenters selects random initial centers in each attempt.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	KMeansRandomCenters KMeansFlags = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// KMeansPPCenters uses kmeans++ center initialization by Arthur and Vassilvitskii [Arthur2007].
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	KMeansPPCenters KMeansFlags = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// KMeansUseInitialLabels uses the user-supplied lables during the first (and possibly the only) attempt
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// instead of computing them from the initial centers. For the second and further attempts, use the random or semi-random     // centers. Use one of KMEANS_*_CENTERS flag to specify the exact method.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	KMeansUseInitialLabels KMeansFlags = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (KMeansFlags) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c KMeansFlags) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type KeyPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type KeyPoint struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	X, Y                  float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Size, Angle, Response float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Octave, ClassID       int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            KeyPoint is data structure for salient point detectors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d2/d29/classcv_1_1KeyPoint.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Layer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Layer struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Layer is a wrapper around the cv::dnn::Layer algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Layer) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (l *Layer) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Close Layer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Layer) GetName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (l *Layer) GetName() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetName returns name for this layer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Layer) GetType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (l *Layer) GetType() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetType returns type for this layer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Layer) InputNameToIndex

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      InputNameToIndex returns index of input blob in input array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d3/d6c/classcv_1_1dnn_1_1Layer.html#a60ffc8238f3fa26cd3f49daa7ac0884b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Layer) OutputNameToIndex

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        OutputNameToIndex returns index of output blob in output array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d3/d6c/classcv_1_1dnn_1_1Layer.html#a60ffc8238f3fa26cd3f49daa7ac0884b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type LineType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type LineType int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          LineType are the line libraries included in OpenCV.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For more information, see: https://vovkos.github.io/doxyrest-showcase/opencv/sphinx_rtd_theme/enum_cv_LineTypes.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Filled line
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Filled LineType = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Line4 4-connected line
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Line4 LineType = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// Line8 8-connected line
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Line8 LineType = 8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// LineAA antialiased line
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	LineAA LineType = 16
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (LineType) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c LineType) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MSER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MSER struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MSER is a wrapper around the cv::MSER algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewMSER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewMSER() MSER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewMSER returns a new MSER algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d3/d28/classcv_1_1MSER.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*MSER) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (a *MSER) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Close MSER.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*MSER) Detect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Detect keypoints in an image using MSER.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#aa4e9a7082ec61ebc108806704fbd7887

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Mat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Mat struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Mat represents an n-dimensional dense numerical single-channel or multi-channel array. It can be used to store real or complex-valued vectors and matrices, grayscale or color images, voxel volumes, vector fields, point clouds, tensors, and histograms.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: http://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func BlobFromImage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BlobFromImage 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/trunk/d6/d0f/group__dnn.html#ga152367f253c81b53fe6862b299f5c5cd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func EstimateAffinePartial2D

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func EstimateAffinePartial2D(from, to Point2fVector) Mat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        EstimateAffinePartial2D computes an optimal limited affine transformation with 4 degrees of freedom between two 2D point sets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d9/d0c/group__calib3d.html#gad767faff73e9cbd8b9d92b955b50062d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func Eye

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Returns an identity matrix of the specified size and type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The method returns a Matlab-style identity matrix initializer, similarly to Mat::zeros. Similarly to Mat::ones. For further details, please see: https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#a2cf9b9acde7a9852542bbc20ef851ed2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func FindHomography

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func FindHomography(srcPoints Mat, dstPoints *Mat, method HomographyMethod, ransacReprojThreshold float64, mask *Mat, maxIters int, confidence float64) Mat

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d9/d0c/group__calib3d.html#ga4abc2ece9fab9398f2e560d53c8c9780

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func GetAffineTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func GetAffineTransform(src, dst PointVector) Mat

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#ga8f6d378f9f8eebb5cb55cd3ae295a999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func GetAffineTransform2f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func GetAffineTransform2f(src, dst Point2fVector) Mat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GetAffineTransform2f returns a 2x3 affine transformation matrix for the corresponding 3 point pairs as gocv.Point2f.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#ga8f6d378f9f8eebb5cb55cd3ae295a999

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func GetBlobChannel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func GetBlobChannel(blob Mat, imgidx int, chnidx int) 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,

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  a bones structure from pose detection, or a color plane from Colorization)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func GetGaussianKernel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func GetGaussianKernel(ksize int, sigma float64) Mat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetGaussianKernel returns Gaussian filter coefficients.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gac05a120c1ae92a6060dd0db190a61afa

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func GetGaussianKernelWithParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GetGaussianKernelWithParams returns Gaussian filter coefficients.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gac05a120c1ae92a6060dd0db190a61afa

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func GetOptimalNewCameraMatrixWithParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func GetOptimalNewCameraMatrixWithParams(cameraMatrix Mat, distCoeffs Mat, imageSize image.Point, alpha float64, newImgSize image.Point, centerPrincipalPoint bool) (Mat, image.Rectangle)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GetOptimalNewCameraMatrixWithParams computes and returns the optimal new camera matrix based on the free scaling parameter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d9/d0c/group__calib3d.html#ga7a6c4e032c97f03ba747966e6ad862b1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func GetPerspectiveTransform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func GetPerspectiveTransform(src, dst PointVector) Mat

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#ga8c1ae0e3589a9d77fffc962c49b22043

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func GetPerspectiveTransform2f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func GetPerspectiveTransform2f(src, dst Point2fVector) Mat

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#ga8c1ae0e3589a9d77fffc962c49b22043

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func GetRotationMatrix2D

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetRotationMatrix2D calculates an affine matrix of 2D rotation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/da/d54/group__imgproc__transform.html#gafbbc470ce83812914a70abfb604f4326

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func GetStructuringElement

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gac342a1bb6eabf6f55c803b09268e36dc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func HOGDefaultPeopleDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func HOGDefaultPeopleDetector() Mat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  HOGDefaultPeopleDetector returns a new Mat with the HOG DefaultPeopleDetector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d5/d33/structcv_1_1HOGDescriptor.html#a660e5cd036fd5ddf0f5767b352acd948

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func IMDecode

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d4/da8/group__imgcodecs.html#ga26a67788faa58ade337f8d28ba0eb19e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func IMRead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func IMRead(name string, flags IMReadFlag) 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: http://docs.opencv.org/master/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func ImageGrayToMatGray

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ImageGrayToMatGray converts image.Gray to gocv.Mat, which represents grayscale image 8bit. Type of Mat is gocv.MatTypeCV8UC1.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func ImageToMatRGB

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ImageToMatRGB converts image.Image to gocv.Mat, which represents RGB image having 8bit for each component. Type of Mat is gocv.MatTypeCV8UC3.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func ImageToMatRGBA

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ImageToMatRGBA converts image.Image to gocv.Mat, which represents RGBA image having 8bit for each component. Type of Mat is gocv.MatTypeCV8UC4.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewMat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewMat() Mat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewMat returns a new empty Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewMatFromBytes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewMatFromBytes returns a new Mat with a specific size and type, initialized from a []byte.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewMatFromScalar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewMatFromScalar(s Scalar, mt MatType) Mat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewMatFromScalar returns a new Mat for a specific Scalar value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewMatWithSize

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewMatWithSize returns a new Mat with a specific size and type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewMatWithSizeFromScalar

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewMatWithSizeFromScalar returns a new Mat for a specific Scala value with a specific size and type This simplifies creation of specific color filters or creating Mats of specific colors and sizes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewMatWithSizes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewMatWithSizes returns a new multidimensional Mat with a specific size and type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewMatWithSizesFromBytes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewMatWithSizesWithScalar returns a new multidimensional Mat with a specific size, type and preexisting data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewMatWithSizesWithScalar

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewMatWithSizesWithScalar returns a new multidimensional Mat with a specific size, type and scalar value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func Ones

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns an array of all 1's of the specified size and type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The method returns a Matlab-style 1's array initializer For further details, please see: https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#a69ae0402d116fc9c71908d8508dc2f09

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func Split

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Split creates an array of single channel images from a multi-channel image Created images should be closed manualy to avoid memory leaks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga0547c7fed86152d7e9d0096029c8518a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func Zeros

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Returns a zero array of the specified size and type.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The method returns a Matlab-style zero array initializer. For further details, please see: https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#a0b57b6a326c8876d944d188a46e0f556

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mat) AddFloat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *Mat) AddFloat(val float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AddFloat adds a float value to each element in the Mat. Performs a mat += val operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mat) AddUChar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *Mat) AddUChar(val uint8)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      AddUChar adds a uchar value to each element in the Mat. Performs a mat += val operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mat) Channels

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *Mat) Channels() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Channels returns the number of channels for this Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mat) Clone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *Mat) Clone() Mat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Clone returns a cloned full copy of the Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mat) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (m *Mat) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Close the Mat object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mat) ColRange

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ColRange creates a matrix header for the specified column span.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#aadc8f9210fe4dec50513746c246fa8d9

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mat) Cols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *Mat) Cols() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Cols returns the number of columns for this Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mat) ConvertFp16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *Mat) ConvertFp16() Mat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ConvertFp16 converts a Mat to half-precision floating point.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga9c25d9ef44a2a48ecc3774b30cb80082

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mat) ConvertTo

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ConvertTo converts Mat into destination Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#adf88c60c5b4980e05bb556080916978b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mat) ConvertToWithParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mat) CopyTo

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CopyTo copies Mat into destination Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#a33fd5d125b4c302b0c9aa86980791a77

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mat) CopyToWithMask

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        CopyToWithMask copies Mat into destination Mat after applying the mask Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#a626fe5f96d02525e2604d2ad46dd574f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mat) DataPtrFloat32

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DataPtrFloat32 returns a slice that references the OpenCV allocated data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The data is no longer valid once the Mat has been closed. Any data that needs to be accessed after the Mat is closed must be copied into Go memory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mat) DataPtrFloat64

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            DataPtrFloat64 returns a slice that references the OpenCV allocated data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The data is no longer valid once the Mat has been closed. Any data that needs to be accessed after the Mat is closed must be copied into Go memory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mat) DataPtrInt16

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DataPtrInt16 returns a slice that references the OpenCV allocated data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The data is no longer valid once the Mat has been closed. Any data that needs to be accessed after the Mat is closed must be copied into Go memory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mat) DataPtrInt8

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DataPtrInt8 returns a slice that references the OpenCV allocated data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The data is no longer valid once the Mat has been closed. Any data that needs to be accessed after the Mat is closed must be copied into Go memory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mat) DataPtrUint16

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DataPtrUint16 returns a slice that references the OpenCV allocated data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The data is no longer valid once the Mat has been closed. Any data that needs to be accessed after the Mat is closed must be copied into Go memory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mat) DataPtrUint8

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DataPtrUint8 returns a slice that references the OpenCV allocated data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The data is no longer valid once the Mat has been closed. Any data that needs to be accessed after the Mat is closed must be copied into Go memory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mat) DivideFloat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *Mat) DivideFloat(val float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DivideFloat divides each element in the Mat by a float value. Performs a mat /= val operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mat) DivideUChar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *Mat) DivideUChar(val uint8)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        DivideUChar divides each element in the Mat by a uint value. Performs a mat /= val operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mat) Empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *Mat) Empty() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Empty determines if the Mat is empty or not.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mat) FromPtr

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            FromPtr returns a new Mat with a specific size and type, initialized from a Mat Ptr.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mat) GetDoubleAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetDoubleAt returns a value from a specific row/col in this Mat expecting it to be of type double aka CV_64F.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mat) GetDoubleAt3

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GetDoubleAt3 returns a value from a specific x, y, z coordinate location in this Mat expecting it to be of type double aka CV_64F.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mat) GetFloatAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetFloatAt returns a value from a specific row/col in this Mat expecting it to be of type float aka CV_32F.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mat) GetFloatAt3

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetFloatAt3 returns a value from a specific x, y, z coordinate location in this Mat expecting it to be of type float aka CV_32F.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mat) GetIntAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GetIntAt returns a value from a specific row/col in this Mat expecting it to be of type int aka CV_32S.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mat) GetIntAt3

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GetIntAt3 returns a value from a specific x, y, z coordinate location in this Mat expecting it to be of type int aka CV_32S.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mat) GetSCharAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetSCharAt returns a value from a specific row/col in this Mat expecting it to be of type schar aka CV_8S.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mat) GetSCharAt3

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GetSCharAt3 returns a value from a specific x, y, z coordinate location in this Mat expecting it to be of type schar aka CV_8S.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mat) GetShortAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetShortAt returns a value from a specific row/col in this Mat expecting it to be of type short aka CV_16S.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mat) GetShortAt3

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GetShortAt3 returns a value from a specific x, y, z coordinate location in this Mat expecting it to be of type short aka CV_16S.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mat) GetUCharAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetUCharAt returns a value from a specific row/col in this Mat expecting it to be of type uchar aka CV_8U.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mat) GetUCharAt3

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetUCharAt3 returns a value from a specific x, y, z coordinate location in this Mat expecting it to be of type uchar aka CV_8U.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mat) GetVecbAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GetVecbAt returns a vector of bytes. Its size corresponds to the number of channels of the Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mat) GetVecdAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GetVecdAt returns a vector of float64s. Its size corresponds to the number of channels of the Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mat) GetVecfAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetVecfAt returns a vector of floats. Its size corresponds to the number of channels of the Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mat) GetVeciAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GetVeciAt returns a vector of integers. Its size corresponds to the number of channels of the Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mat) IsContinuous

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (m *Mat) IsContinuous() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IsContinuous determines if the Mat is continuous.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#aa90cea495029c7d1ee0a41361ccecdf3

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mat) Mean

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (m *Mat) Mean() Scalar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Mean calculates the mean value M of array elements, independently for each channel, and return it as Scalar For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga191389f8a0e58180bb13a727782cd461

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mat) MeanWithMask

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MeanWithMask calculates the mean value M of array elements,independently for each channel, and returns it as Scalar vector while applying the mask. https://docs.opencv.org/master/d2/de8/group__core__array.html#ga191389f8a0e58180bb13a727782cd461

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mat) MultiplyFloat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *Mat) MultiplyFloat(val float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MultiplyFloat multiplies each element in the Mat by a float value. Performs a mat *= val operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mat) MultiplyMatrix

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MultiplyMatrix multiplies matrix (m*x)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mat) MultiplyUChar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *Mat) MultiplyUChar(val uint8)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MultiplyUChar multiplies each element in the Mat by a uint value. Performs a mat *= val operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mat) PatchNaNs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *Mat) PatchNaNs()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          PatchNaNs converts NaN's to zeros.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga62286befb7cde3568ff8c7d14d5079da

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mat) Ptr

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Ptr returns the Mat's underlying object pointer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mat) Region

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Region returns a new Mat that points to a region of this Mat. Changes made to the region Mat will affect the original Mat, since they are pointers to the underlying OpenCV Mat object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mat) Reshape

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Reshape changes the shape and/or the number of channels of a 2D matrix without copying the data.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#a4eb96e3251417fa88b78e2abd6cfd7d8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mat) RowRange

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RowRange creates a matrix header for the specified row span.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#aa6542193430356ad631a9beabc624107

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mat) Rows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *Mat) Rows() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Rows returns the number of rows for this Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mat) SetDoubleAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetDoubleAt sets a value at a specific row/col in this Mat expecting it to be of type double aka CV_64F.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mat) SetDoubleAt3

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetDoubleAt3 sets a value at a specific x, y, z coordinate location in this Mat expecting it to be of type double aka CV_64F.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mat) SetFloatAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetFloatAt sets a value at a specific row/col in this Mat expecting it to be of type float aka CV_32F.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mat) SetFloatAt3

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetFloatAt3 sets a value at a specific x, y, z coordinate location in this Mat expecting it to be of type float aka CV_32F.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mat) SetIntAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetIntAt sets a value at a specific row/col in this Mat expecting it to be of type int aka CV_32S.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mat) SetIntAt3

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetIntAt3 sets a value at a specific x, y, z coordinate location in this Mat expecting it to be of type int aka CV_32S.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mat) SetSCharAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetSCharAt sets a value at a specific row/col in this Mat expecting it to be of type schar aka CV_8S.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mat) SetSCharAt3

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetSCharAt3 sets a value at a specific x, y, z coordinate location in this Mat expecting it to be of type schar aka CV_8S.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mat) SetShortAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetShortAt sets a value at a specific row/col in this Mat expecting it to be of type short aka CV_16S.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mat) SetShortAt3

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetShortAt3 sets a value at a specific x, y, z coordinate location in this Mat expecting it to be of type short aka CV_16S.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mat) SetTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *Mat) SetTo(s Scalar)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetTo sets all or some of the array elements to the specified scalar value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mat) SetUCharAt

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetUCharAt sets a value at a specific row/col in this Mat expecting it to be of type uchar aka CV_8U.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mat) SetUCharAt3

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetUCharAt3 sets a value at a specific x, y, z coordinate location in this Mat expecting it to be of type uchar aka CV_8U.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mat) Size

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Size returns an array with one element for each dimension containing the size of that dimension for the Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#aa4d317d43fb0cba9c2503f3c61b866c8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mat) Sqrt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (m *Mat) Sqrt() Mat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Sqrt calculates a square root of array elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga186222c3919657890f88df5a1f64a7d7

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mat) Step

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *Mat) Step() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Step returns the number of bytes each matrix row occupies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mat) SubtractFloat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *Mat) SubtractFloat(val float32)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SubtractFloat subtracts a float value from each element in the Mat. Performs a mat -= val operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Mat) SubtractUChar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (m *Mat) SubtractUChar(val uint8)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SubtractUChar subtracts a uchar value from each element in the Mat. Performs a mat -= val operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Mat) Sum

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (m *Mat) Sum() Scalar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Sum calculates the per-channel pixel sum of an image.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga716e10a2dd9e228e4d3c95818f106722

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Mat) ToBytes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ToBytes copies the underlying Mat data to a byte array.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/3.3.1/d3/d63/classcv_1_1Mat.html#a4d33bed1c850265370d2af0ff02e1564

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Mat) ToImage

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ToImage converts a Mat to a image.Image.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Mat) ToImageYUV

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ToImageYUV converts a Mat to a image.YCbCr using image.YCbCrSubsampleRatio420 as default subsampling param.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Mat) ToImageYUVWithParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ToImageYUV converts a Mat to a image.YCbCr using provided YUV subsample ratio param.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Mat) Total

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (m *Mat) Total() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Total returns the total number of array elements.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d3/d63/classcv_1_1Mat.html#aa4d317d43fb0cba9c2503f3c61b866c8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Mat) Type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (m *Mat) Type() MatType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type returns the type for this Mat.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MatType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type MatType int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        MatType is the type for the various different kinds of Mat you can create.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (MatType) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (c MatType) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type MorphShape

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type MorphShape int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MorphShape is the shape of the structuring element used for Morphing operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// MorphRect is the rectangular morph shape.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MorphRect MorphShape = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// MorphCross is the cross morph shape.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MorphCross MorphShape = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// MorphEllipse is the ellipse morph shape.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MorphEllipse MorphShape = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (MorphShape) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c MorphShape) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MorphType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type MorphType int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            MorphType type of morphological operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// MorphErode operation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MorphErode MorphType = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// MorphDilate operation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MorphDilate MorphType = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// MorphOpen operation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MorphOpen MorphType = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// MorphClose operation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MorphClose MorphType = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// MorphGradient operation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MorphGradient MorphType = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// MorphTophat operation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MorphTophat MorphType = 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// MorphBlackhat operation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MorphBlackhat MorphType = 6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// MorphHitmiss operation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	MorphHitmiss MorphType = 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (MorphType) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (c MorphType) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Net

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Net struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Net allows you to create and manipulate comprehensive artificial neural networks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/db/d30/classcv_1_1dnn_1_1Net.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func ReadNet

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func ReadNet(model string, config string) Net

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ReadNet reads a deep learning network represented in one of the supported formats.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/3.4/d6/d0f/group__dnn.html#ga3b34fe7a29494a6a4295c169a7d32422

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func ReadNetBytes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ReadNetBytes reads a deep learning network represented in one of the supported formats.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d6/d0f/group__dnn.html#ga138439da76f26266fdefec9723f6c5cd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func ReadNetFromCaffe

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func ReadNetFromCaffe(prototxt string, caffeModel string) Net

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ReadNetFromCaffe reads a network model stored in Caffe framework's format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d6/d0f/group__dnn.html#ga29d0ea5e52b1d1a6c2681e3f7d68473a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func ReadNetFromCaffeBytes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ReadNetFromCaffeBytes reads a network model stored in Caffe model in memory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d6/d0f/group__dnn.html#ga946b342af1355185a7107640f868b64a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func ReadNetFromONNX

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func ReadNetFromONNX(model string) Net

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ReadNetFromONNX reads a network model stored in ONNX framework's format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        check net.Empty() for read failure
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d6/d0f/group__dnn.html#ga7faea56041d10c71dbbd6746ca854197

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func ReadNetFromONNXBytes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ReadNetFromONNXBytes reads a network model stored in ONNX framework's format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d6/d0f/group__dnn.html#ga9198ecaac7c32ddf0aa7a1bcbd359567

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func ReadNetFromTensorflow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func ReadNetFromTensorflow(model string) Net

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ReadNetFromTensorflow reads a network model stored in Tensorflow framework's format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d6/d0f/group__dnn.html#gad820b280978d06773234ba6841e77e8d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func ReadNetFromTensorflowBytes

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ReadNetFromTensorflowBytes reads a network model stored in Tensorflow framework's format.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d6/d0f/group__dnn.html#gacdba30a7c20db2788efbf5bb16a7884d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func ReadNetFromTorch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func ReadNetFromTorch(model string) Net

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ReadNetFromTorch reads a network model stored in Torch framework's format (t7).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                check net.Empty() for read failure
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d6/d0f/group__dnn.html#gaaaed8c8530e9e92fe6647700c13d961e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Net) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (net *Net) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Close Net

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Net) Empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (net *Net) Empty() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Empty returns true if there are no layers in the network.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/db/d30/classcv_1_1dnn_1_1Net.html#a6a5778787d5b8770deab5eda6968e66c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Net) Forward

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Forward runs forward pass to compute output of layer with name outputName.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/trunk/db/d30/classcv_1_1dnn_1_1Net.html#a98ed94cb6ef7063d3697259566da310b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Net) ForwardLayers

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ForwardLayers forward pass to compute outputs of layers listed in outBlobNames.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/3.4.1/db/d30/classcv_1_1dnn_1_1Net.html#adb34d7650e555264c7da3b47d967311b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Net) GetLayer

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetLayer returns pointer to layer with specified id from the network.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/db/d30/classcv_1_1dnn_1_1Net.html#a70aec7f768f38c32b1ee25f3a56526df

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Net) GetLayerNames

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GetLayerNames returns all layer names.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For furtherdetails, please see: https://docs.opencv.org/master/db/d30/classcv_1_1dnn_1_1Net.html#ae8be9806024a0d1d41aba687cce99e6b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Net) GetPerfProfile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (net *Net) GetPerfProfile() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetPerfProfile returns overall time for inference and timings (in ticks) for layers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/db/d30/classcv_1_1dnn_1_1Net.html#a06ce946f675f75d1c020c5ddbc78aedc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Net) GetUnconnectedOutLayers

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GetUnconnectedOutLayers returns indexes of layers with unconnected outputs.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/db/d30/classcv_1_1dnn_1_1Net.html#ae62a73984f62c49fd3e8e689405b056a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Net) SetInput

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetInput sets the new value for the layer output blob.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/trunk/db/d30/classcv_1_1dnn_1_1Net.html#a672a08ae76444d75d05d7bfea3e4a328

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Net) SetPreferableBackend

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetPreferableBackend ask network to use specific computation backend.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/3.4/db/d30/classcv_1_1dnn_1_1Net.html#a7f767df11386d39374db49cd8df8f59e

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Net) SetPreferableTarget

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetPreferableTarget ask network to make computations on specific target device.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/3.4/db/d30/classcv_1_1dnn_1_1Net.html#a9dddbefbc7f3defbe3eeb5dc3d3483f4

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type NetBackendType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type NetBackendType int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NetBackendType is the type for the various different kinds of DNN backends.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// NetBackendDefault is the default backend.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	NetBackendDefault NetBackendType = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// NetBackendHalide is the Halide backend.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	NetBackendHalide NetBackendType = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// NetBackendOpenVINO is the OpenVINO backend.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	NetBackendOpenVINO NetBackendType = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// NetBackendOpenCV is the OpenCV backend.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	NetBackendOpenCV NetBackendType = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// NetBackendVKCOM is the Vulkan backend.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	NetBackendVKCOM NetBackendType = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// NetBackendCUDA is the Cuda backend.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	NetBackendCUDA NetBackendType = 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func ParseNetBackend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func ParseNetBackend(backend string) NetBackendType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ParseNetBackend returns a valid NetBackendType given a string. Valid values are: - halide - openvino - opencv - vulkan - cuda - default

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (NetBackendType) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c NetBackendType) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NetTargetType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NetTargetType int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NetTargetType is the type for the various different kinds of DNN device targets.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// NetTargetCPU is the default CPU device target.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	NetTargetCPU NetTargetType = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// NetTargetFP32 is the 32-bit OpenCL target.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	NetTargetFP32 NetTargetType = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// NetTargetFP16 is the 16-bit OpenCL target.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	NetTargetFP16 NetTargetType = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// NetTargetVPU is the Movidius VPU target.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	NetTargetVPU NetTargetType = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// NetTargetVulkan is the NVIDIA Vulkan target.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	NetTargetVulkan NetTargetType = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// NetTargetFPGA is the FPGA target.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	NetTargetFPGA NetTargetType = 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// NetTargetCUDA is the CUDA target.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	NetTargetCUDA NetTargetType = 6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// NetTargetCUDAFP16 is the CUDA target.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	NetTargetCUDAFP16 NetTargetType = 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func ParseNetTarget

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func ParseNetTarget(target string) NetTargetType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ParseNetTarget returns a valid NetTargetType given a string. Valid values are: - cpu - fp32 - fp16 - vpu - vulkan - fpga - cuda - cudafp16

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (NetTargetType) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c NetTargetType) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NormType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NormType int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NormType for normalization operations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#gad12cefbcb5291cf958a85b4b67b6149f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NormInf indicates use infinite normalization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NormInf NormType = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NormL1 indicates use L1 normalization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NormL1 NormType = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NormL2 indicates use L2 normalization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NormL2 NormType = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NormL2Sqr indicates use L2 squared normalization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NormL2Sqr NormType = 5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NormHamming indicates use Hamming normalization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NormHamming NormType = 6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NormHamming2 indicates use Hamming 2-bit normalization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NormHamming2 NormType = 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NormTypeMask indicates use type mask for normalization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NormTypeMask NormType = 7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NormRelative indicates use relative normalization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NormRelative NormType = 8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NormMinMax indicates use min/max normalization.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NormMinMax NormType = 32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (NormType) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c NormType) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ORB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ORB struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ORB is a wrapper around the cv::ORB.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewORB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewORB() ORB

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewORB returns a new ORB algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d7/d19/classcv_1_1AgastFeatureDetector.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*ORB) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (o *ORB) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Close ORB.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*ORB) Detect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Detect keypoints in an image using ORB.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#aa4e9a7082ec61ebc108806704fbd7887

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*ORB) DetectAndCompute

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DetectAndCompute detects keypoints and computes from an image using ORB.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#a8be0d1c20b08eb867184b8d74c15a677

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Point2f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Point2f struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	X float32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Y float32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func PhaseCorrelate

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Apply phaseCorrelate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d7/df3/group__imgproc__motion.html#ga552420a2ace9ef3fb053cd630fdb4952

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Point2fVector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Point2fVector struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Point2fVector is a wrapper around a std::vector< cv::Point2f >* This is needed anytime that you need to pass or receive a collection of points.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewPoint2fVector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewPoint2fVector() Point2fVector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewPoint2fVector returns a new empty Point2fVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewPoint2fVectorFromPoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewPoint2fVectorFromPoints(pts []Point2f) Point2fVector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewPoint2fVectorFromPoints returns a new Point2fVector that has been initialized to a slice of image.Point.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (Point2fVector) At

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (pfv Point2fVector) At(idx int) Point2f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    At returns the image.Point

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (Point2fVector) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (pfv Point2fVector) Close()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Close closes and frees memory for this Point2fVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (Point2fVector) IsNil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (pfv Point2fVector) IsNil() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        IsNil checks the CGo pointer in the Point2fVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (Point2fVector) Size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (pfv Point2fVector) Size() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Size returns how many Point are in the PointVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (Point2fVector) ToPoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (pfv Point2fVector) ToPoints() []Point2f

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ToPoints returns a slice of image.Point for the data in this PointVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PointVector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PointVector struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              PointVector is a wrapper around a std::vector< cv::Point >* This is needed anytime that you need to pass or receive a collection of points.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func ApproxPolyDP

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#ga0012a5fdaea70b8a9970165d98722b4c

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewPointVector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewPointVector() PointVector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewPointVector returns a new empty PointVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewPointVectorFromPoints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewPointVectorFromPoints(pts []image.Point) PointVector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewPointVectorFromPoints returns a new PointVector that has been initialized to a slice of image.Point.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (PointVector) Append

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Append appends an image.Point at end of the PointVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (PointVector) At

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        At returns the image.Point

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (PointVector) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (pv PointVector) Close()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Close closes and frees memory for this PointVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (PointVector) IsNil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (pv PointVector) IsNil() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            IsNil checks the CGo pointer in the PointVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (PointVector) Size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (pv PointVector) Size() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Size returns how many Point are in the PointVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (PointVector) ToPoints

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ToPoints returns a slice of image.Point for the data in this PointVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type PointsVector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type PointsVector struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  PointsVector is a wrapper around a std::vector< std::vector< cv::Point > >*

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func FindContours

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    FindContours finds contours in a binary image.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#ga95f5b48d01abc7c2e0732db24689837b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func FindContoursWithParams

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FindContoursWithParams finds contours in a binary image.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#ga17ed9f5d79ae97bd4c7cf18403e1689a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewPointsVector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewPointsVector() PointsVector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewPointsVector returns a new empty PointsVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewPointsVectorFromPoints

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewPointsVectorFromPoints returns a new PointsVector that has been initialized to a slice of slices of image.Point.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (PointsVector) Append

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (pvs PointsVector) Append(pv PointVector)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Append appends a PointVector at end of the PointsVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (PointsVector) At

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (pvs PointsVector) At(idx int) PointVector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              At returns the PointVector at that index of the PointsVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (PointsVector) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (pvs PointsVector) Close()

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Close closes and frees memory for this PointsVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (PointsVector) IsNil

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (pvs PointsVector) IsNil() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  IsNil checks the CGo pointer in the PointsVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (PointsVector) Size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (pvs PointsVector) Size() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Size returns how many vectors of Points are in the PointsVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (PointsVector) ToPoints

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ToPoints returns a slice of slices of image.Point for the data in this PointsVector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type QRCodeDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type QRCodeDetector struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        QRCodeDetector groups the object candidate rectangles.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/de/dc3/classcv_1_1QRCodeDetector.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewQRCodeDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewQRCodeDetector() QRCodeDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*QRCodeDetector) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (a *QRCodeDetector) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*QRCodeDetector) Decode

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Decode decodes QR code in image once it's found by the detect() method. Returns UTF8-encoded output string or empty string if the code cannot be decoded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/de/dc3/classcv_1_1QRCodeDetector.html#a4172c2eb4825c844fb1b0ae67202d329

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*QRCodeDetector) Detect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Detect detects QR code in image and returns the quadrangle containing the code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/de/dc3/classcv_1_1QRCodeDetector.html#a64373f7d877d27473f64fe04bb57d22b

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*QRCodeDetector) DetectAndDecode

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DetectAndDecode Both detects and decodes QR code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Returns true as long as some QR code was detected even in case where the decoding failed For further details, please see: https://docs.opencv.org/master/de/dc3/classcv_1_1QRCodeDetector.html#a7290bd6a5d59b14a37979c3a14fbf394

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*QRCodeDetector) DetectAndDecodeMulti

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Detects QR codes in image and finds of the quadrangles containing the codes and decode the decode the QRCodes to strings.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Each quadrangle would be returned as a row in the `points` Mat and each point is a Vecf. Returns true as long as some QR code was detected even in case where the decoding failed For usage please see TestQRCodeDetector For further details, please see: https://docs.opencv.org/master/de/dc3/classcv_1_1QRCodeDetector.html#a188b63ffa17922b2c65d8a0ab7b70775

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*QRCodeDetector) DetectMulti

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Detects QR codes in image and finds of the quadrangles containing the codes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Each quadrangle would be returned as a row in the `points` Mat and each point is a Vecf. Returns true if QR code was detected For usage please see TestQRCodeDetector For further details, please see: https://docs.opencv.org/master/de/dc3/classcv_1_1QRCodeDetector.html#aaf2b6b2115b8e8fbc9acf3a8f68872b6

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RNG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RNG struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RNG Random Number Generator. It encapsulates the state (currently, a 64-bit integer) and has methods to return scalar random values and to fill arrays with random values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d1/dd6/classcv_1_1RNG.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func TheRNG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func TheRNG() RNG

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TheRNG Returns the default random number generator.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga75843061d150ad6564b5447e38e57722

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*RNG) Fill

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Fill Fills arrays with random numbers.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d1/dd6/classcv_1_1RNG.html#ad26f2b09d9868cf108e84c9814aa682d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*RNG) Gaussian

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Gaussian Returns the next random number sampled from the Gaussian distribution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          For further details, please see: https://docs.opencv.org/master/d1/dd6/classcv_1_1RNG.html#a8df8ce4dc7d15916cee743e5a884639d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*RNG) Next

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (r *RNG) Next() uint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Next The method updates the state using the MWC algorithm and returns the next 32-bit random number.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d1/dd6/classcv_1_1RNG.html#a8df8ce4dc7d15916cee743e5a884639d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RNGDistType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RNGDistType int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Uniform distribution
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	RNGDistUniform RNGDistType = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// Normal distribution
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	RNGDistNormal RNGDistType = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ReduceTypes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ReduceTypes int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The output is the sum of all rows/columns of the matrix.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ReduceSum ReduceTypes = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The output is the mean vector of all rows/columns of the matrix.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ReduceAvg ReduceTypes = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The output is the maximum (column/row-wise) of all rows/columns of the matrix.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ReduceMax ReduceTypes = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// The output is the minimum (column/row-wise) of all rows/columns of the matrix.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ReduceMin ReduceTypes = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (ReduceTypes) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (c ReduceTypes) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RetrievalMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RetrievalMode int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RetrievalMode is the mode of the contour retrieval algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// RetrievalExternal retrieves only the extreme outer contours.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// It sets `hierarchy[i][2]=hierarchy[i][3]=-1` for all the contours.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	RetrievalExternal RetrievalMode = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// RetrievalList retrieves all of the contours without establishing
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// any hierarchical relationships.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	RetrievalList RetrievalMode = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// RetrievalCComp retrieves all of the contours and organizes them into
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// a two-level hierarchy. At the top level, there are external boundaries
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// of the components. At the second level, there are boundaries of the holes.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// If there is another contour inside a hole of a connected component, it
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// is still put at the top level.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	RetrievalCComp RetrievalMode = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// RetrievalTree retrieves all of the contours and reconstructs a full
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// hierarchy of nested contours.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	RetrievalTree RetrievalMode = 3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// RetrievalFloodfill lacks a description in the original header.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	RetrievalFloodfill RetrievalMode = 4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (RetrievalMode) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (c RetrievalMode) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RotateFlag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RotateFlag int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                RotateFlag for image rotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga6f45d55c0b1cc9d97f5353a7c8a7aac2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Rotate90Clockwise allows to rotate image 90 degrees clockwise
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Rotate90Clockwise RotateFlag = 0
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Rotate180Clockwise allows to rotate image 180 degrees clockwise
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Rotate180Clockwise RotateFlag = 1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// Rotate90CounterClockwise allows to rotate 270 degrees clockwise
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Rotate90CounterClockwise RotateFlag = 2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (RotateFlag) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (c RotateFlag) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RotatedRect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RotatedRect struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Points       []image.Point
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	BoundingRect image.Rectangle
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Center       image.Point
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Width        int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Height       int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Angle        float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func FitEllipse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func FitEllipse(pts PointVector) RotatedRect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  For further details, please see: https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#gaf259efaad93098103d6c27b9e4900ffa

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func MinAreaRect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func MinAreaRect(points PointVector) RotatedRect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d3/dc0/group__imgproc__shape.html#ga3d476a3417130ae5154aea421ca7ead9

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SIFT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SIFT struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SIFT is a wrapper around the cv::SIFT algorithm. Due to the patent having expired, this is now in the main OpenCV code modules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSIFT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSIFT() SIFT

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewSIFT returns a new SIFT algorithm.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d5/d3c/classcv_1_1xfeatures2d_1_1SIFT.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*SIFT) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (d *SIFT) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Close SIFT.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*SIFT) Detect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Detect keypoints in an image using SIFT.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#aa4e9a7082ec61ebc108806704fbd7887

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*SIFT) DetectAndCompute

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DetectAndCompute detects and computes keypoints in an image using SIFT.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#a8be0d1c20b08eb867184b8d74c15a677

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Scalar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Scalar struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Val1 float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Val2 float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Val3 float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Val4 float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Scalar is a 4-element vector widely used in OpenCV to pass pixel values.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: http://docs.opencv.org/master/d1/da0/classcv_1_1Scalar__.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func GetBlobSize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func GetBlobSize(blob Mat) Scalar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetBlobSize retrieves the 4 dimensional size information in (N,C,H,W) order

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func MorphologyDefaultBorderValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func MorphologyDefaultBorderValue() Scalar

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#ga94756fad83d9d24d29c9bf478558c40a

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewScalar

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewScalar returns a new Scalar. These are usually colors typically being in BGR order.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func Trace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func Trace(src Mat) Scalar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Trace returns the trace of a matrix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        For further details, please see: https://docs.opencv.org/master/d2/de8/group__core__array.html#ga3419ac19c7dcd2be4bd552a23e147dd8

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SeamlessCloneFlags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SeamlessCloneFlags int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SeamlessCloneFlags seamlessClone algorithm flags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// NormalClone The power of the method is fully expressed when inserting objects with complex outlines into a new background.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	NormalClone SeamlessCloneFlags = iota
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// MixedClone The classic method, color-based selection and alpha masking might be time consuming and often leaves an undesirable halo. Seamless cloning, even averaged with the original image, is not effective. Mixed seamless cloning based on a loose selection proves effective.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MixedClone
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// MonochromeTransfer Monochrome transfer allows the user to easily replace certain features of one object by alternative features.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	MonochromeTransfer
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (SeamlessCloneFlags) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (c SeamlessCloneFlags) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SimpleBlobDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SimpleBlobDetector struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SimpleBlobDetector is a wrapper around the cv::SimpleBlobDetector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewSimpleBlobDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewSimpleBlobDetector() SimpleBlobDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewSimpleBlobDetector returns a new SimpleBlobDetector algorithm

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              For further details, please see: https://docs.opencv.org/master/d0/d7a/classcv_1_1SimpleBlobDetector.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewSimpleBlobDetectorWithParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewSimpleBlobDetectorWithParams(params SimpleBlobDetectorParams) SimpleBlobDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewSimpleBlobDetectorWithParams returns a new SimpleBlobDetector with custom parameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                For further details, please see: https://docs.opencv.org/master/d0/d7a/classcv_1_1SimpleBlobDetector.html

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*SimpleBlobDetector) Close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (b *SimpleBlobDetector) Close() error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Close SimpleBlobDetector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*SimpleBlobDetector) Detect

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Detect keypoints in an image using SimpleBlobDetector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    For further details, please see: https://docs.opencv.org/master/d0/d13/classcv_1_1Feature2D.html#aa4e9a7082ec61ebc108806704fbd7887

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SimpleBlobDetectorParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SimpleBlobDetectorParams struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SimpleBlobDetector_Params is a wrapper around the cv::SimpleBlobdetector::Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSimpleBlobDetectorParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSimpleBlobDetectorParams() SimpleBlobDetectorParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewSimpleBlobDetectorParams returns the default parameters for the SimpleBobDetector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*SimpleBlobDetectorParams) GetBlobColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (p *SimpleBlobDetectorParams) GetBlobColor() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetBlobColor gets the blobColor field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*SimpleBlobDetectorParams) GetFilterByArea

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (p *SimpleBlobDetectorParams) GetFilterByArea() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GetFilterByArea gets the filterByArea field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*SimpleBlobDetectorParams) GetFilterByCircularity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (p *SimpleBlobDetectorParams) GetFilterByCircularity() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetFilterByCircularity gets the filterByCircularity field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*SimpleBlobDetectorParams) GetFilterByColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (p *SimpleBlobDetectorParams) GetFilterByColor() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GetFilterByColor gets the filterByColor field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*SimpleBlobDetectorParams) GetFilterByConvexity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (p *SimpleBlobDetectorParams) GetFilterByConvexity() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetFilterByConvexity gets the filterByConvexity field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*SimpleBlobDetectorParams) GetFilterByInertia

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (p *SimpleBlobDetectorParams) GetFilterByInertia() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetFilterByInertia gets the filterByInertia field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*SimpleBlobDetectorParams) GetMaxArea

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (p *SimpleBlobDetectorParams) GetMaxArea() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GetMaxArea sets the maxArea parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*SimpleBlobDetectorParams) GetMaxCircularity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (p *SimpleBlobDetectorParams) GetMaxCircularity() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GetMaxCircularity sets the maxCircularity parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*SimpleBlobDetectorParams) GetMaxConvexity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (p *SimpleBlobDetectorParams) GetMaxConvexity() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetMaxConvexity sets the maxConvexity parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*SimpleBlobDetectorParams) GetMaxInertiaRatio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (p *SimpleBlobDetectorParams) GetMaxInertiaRatio() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GetMaxInertiaRatio sets the maxCConvexity parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*SimpleBlobDetectorParams) GetMaxThreshold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (p *SimpleBlobDetectorParams) GetMaxThreshold() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetMaxThreshold sets the maxCConvexity parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*SimpleBlobDetectorParams) GetMinArea

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (p *SimpleBlobDetectorParams) GetMinArea() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                GetMinArea sets theinArea parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*SimpleBlobDetectorParams) GetMinCircularity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (p *SimpleBlobDetectorParams) GetMinCircularity() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  GetMinCircularity sets the minCircularity parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*SimpleBlobDetectorParams) GetMinConvexity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (p *SimpleBlobDetectorParams) GetMinConvexity() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    GetMinConvexity sets the minConvexity parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*SimpleBlobDetectorParams) GetMinDistBetweenBlobs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (p *SimpleBlobDetectorParams) GetMinDistBetweenBlobs() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      GetMinDistBetweenBlobs sets the minDistBetweenBlobs parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*SimpleBlobDetectorParams) GetMinInertiaRatio

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (p *SimpleBlobDetectorParams) GetMinInertiaRatio() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        GetMinInertiaRatio sets the minInertiaRatio parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*SimpleBlobDetectorParams) GetMinRepeatability

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (p *SimpleBlobDetectorParams) GetMinRepeatability() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          GetMinInertiaRatio sets the minRepeatability parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*SimpleBlobDetectorParams) GetMinThreshold

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (p *SimpleBlobDetectorParams) GetMinThreshold() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            GetMinThreshold sets the minInertiaRatio parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*SimpleBlobDetectorParams) GetThresholdStep

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (p *SimpleBlobDetectorParams) GetThresholdStep() float64

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GetMinThreshold sets the minInertiaRatio parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*SimpleBlobDetectorParams) SetBlobColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (p *SimpleBlobDetectorParams) SetBlobColor(blobColor int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SetBlobColor sets the blobColor field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*SimpleBlobDetectorParams) SetFilterByArea

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (p *SimpleBlobDetectorParams) SetFilterByArea(filterByArea bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetFilterByArea sets the filterByArea field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*SimpleBlobDetectorParams) SetFilterByCircularity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (p *SimpleBlobDetectorParams) SetFilterByCircularity(filterByCircularity bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetFilterByCircularity sets the filterByCircularity field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*SimpleBlobDetectorParams) SetFilterByColor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (p *SimpleBlobDetectorParams) SetFilterByColor(filterByColor bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetFilterByColor sets the filterByColor field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*SimpleBlobDetectorParams) SetFilterByConvexity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (p *SimpleBlobDetectorParams) SetFilterByConvexity(filterByConvexity bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetFilterByConvexity sets the filterByConvexity field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*SimpleBlobDetectorParams) SetFilterByInertia

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (p *SimpleBlobDetectorParams) SetFilterByInertia(filterByInertia bool)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetFilterByInertia sets the filterByInertia field

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*SimpleBlobDetectorParams) SetMaxArea

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (p *SimpleBlobDetectorParams) SetMaxArea(maxArea float64)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SetMaxArea sets the maxArea parameter for SimpleBlobDetector_Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*SimpleBlobDetectorParams) SetMaxCircularity