OpenCV

https://docs.opencv.org/4.6.0/
Admin
OpenCV is an open-source computer vision library providing tools for image processing, video...
Tokens:1,860,976
Snippets:17,297
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Compile and Install

Source: https://docs.opencv.org/4.6.0/d2/de6/tutorial_py_setup_in_ubuntu.html

Builds the binaries and installs them to the system.

```bash
$ make
```

--------------------------------

### Setup Node.js project with Jimp

Source: https://docs.opencv.org/4.6.0/dc/de6/tutorial_js_nodejs.html

Commands to initialize a project and install the Jimp dependency for image processing.

```bash
mkdir project1
cd project1
npm init -y
npm install jimp
```

--------------------------------

### Commandline Parser Example

Source: https://docs.opencv.org/4.6.0/df/d4a/tutorial_charuco_detection.html

Example of commandline arguments for the create_board_charuco.cpp sample.

```text
_output_path_/chboard.png -w=5 -h=7 -sl=200 -ml=120 -d=10
```

--------------------------------

### Initializing Video Capture

Source: https://docs.opencv.org/4.6.0/dd/d43/tutorial_py_video_display.html

Basic setup to start capturing video from the default camera.

```python
import numpy as np
import cv2 as cv
cap = cv.VideoCapture(0)
```

--------------------------------

### Video I/O Backend Usage Examples

Source: https://docs.opencv.org/4.6.0/d1/da2/registry_8hpp.html

Examples of how to use specific registry functions within code.

```cpp
cv::VideoCapture(int index)
```

```cpp
cv::VideoCapture(filename)
```

```cpp
cv::VideoWriter()
```

--------------------------------

### Install Build Prerequisites

Source: https://docs.opencv.org/4.6.0/d7/d9f/tutorial_linux_install.html

Commands to install necessary compilers, build tools, and utilities on Ubuntu.

```bash
sudo apt install -y g++
```

```bash
sudo apt install -y clang
```

```bash
sudo apt install -y cmake
```

```bash
sudo apt install -y make
```

```bash
sudo apt install -y ninja-build
```

```bash
sudo apt install -y wget unzip
```

```bash
sudo apt install -y git
```

--------------------------------

### Install OpenCV Binaries

Source: https://docs.opencv.org/4.6.0/d7/d9f/tutorial_linux_install.html

Commands to install the built files to the system directory.

```bash
sudo make install
```

```bash
sudo ninja install
```

--------------------------------

### Install OpenCV

Source: https://docs.opencv.org/4.6.0/d0/d3d/tutorial_general_install.html

Copy build artifacts to the installation directory.

```bash
cmake --build <build-directory> --target install <other-options>
```

--------------------------------

### Run Example via Command Line

Source: https://docs.opencv.org/4.6.0/d5/de7/tutorial_dnn_googlenet.html

Executes the classification example with specific model parameters.

```bash
./example_dnn_classification --model=bvlc_googlenet.caffemodel --config=bvlc_googlenet.prototxt --width=224 --height=224 --classes=classification_classes_ILSVRC2012.txt --input=space_shuttle.jpg --mean="104 117 123"
```

--------------------------------

### Execute Installation Script

Source: https://docs.opencv.org/4.6.0/db/d4c/tutorial_install_tesseract.html

Command to run the Tesseract installation script.

```bash
./installTesseract.sh
```

--------------------------------

### Build and Install OpenCV

Source: https://docs.opencv.org/4.6.0/dd/dd5/tutorial_py_setup_in_fedora.html

Commands to compile the source code and install the resulting binaries.

```bash
make
su
make install
```

--------------------------------

### Main Execution and Pattern Setup

Source: https://docs.opencv.org/4.6.0/dc/da9/tutorial_decode_graycode_pattern.html

Initializes GrayCodePattern parameters and loads calibration data.

```cpp
int main( int argc, char** argv )
{
structured_light::GrayCodePattern::Params params;
CommandLineParser parser( argc, argv, keys );
String images_file = parser.get<String>( 0 );
String calib_file = parser.get<String>( 1 );
params.width = parser.get<int>( 2 );
params.height = parser.get<int>( 3 );
if( images_file.empty() || calib_file.empty() || params.width < 1 || params.height < 1 || argc < 5 || argc > 7 )
{
help();
return -1;
}
// Set up GraycodePattern with params
Ptr<structured_light::GrayCodePattern> graycode = structured_light::GrayCodePattern::create( params );
size_t white_thresh = 0;
size_t black_thresh = 0;
if( argc == 7 )
{
// If passed, setting the white and black threshold, otherwise using default values
white_thresh = parser.get<unsigned>( 4 );
black_thresh = parser.get<unsigned>( 5 );
graycode->setWhiteThreshold( white_thresh );
graycode->setBlackThreshold( black_thresh );
}
vector<string> imagelist;
bool ok = readStringList( images_file, imagelist );
if( !ok || imagelist.empty() )
{
cout << "can not open " << images_file << " or the string list is empty" << endl;
help();
return -1;
}
FileStorage fs( calib_file, FileStorage::READ );
if( !fs.isOpened() )
{
cout << "Failed to open Calibration Data File." << endl;
help();
return -1;
}
// Loading calibration parameters
Mat cam1intrinsics, cam1distCoeffs, cam2intrinsics, cam2distCoeffs, R, T;
fs["cam1_intrinsics"] >> cam1intrinsics;
fs["cam2_intrinsics"] >> cam2intrinsics;
fs["cam1_distorsion"] >> cam1distCoeffs;
fs["cam2_distorsion"] >> cam2distCoeffs;
fs["R"] >> R;
fs["T"] >> T;
cout << "cam1intrinsics" << endl << cam1intrinsics << endl;
cout << "cam1distCoeffs" << endl << cam1distCoeffs << endl;
cout << "cam2intrinsics" << endl << cam2intrinsics << endl;
cout << "cam2distCoeffs" << endl << cam2distCoeffs << endl;
cout << "T" << endl << T << endl << "R" << endl << R << endl;
if( (!R.data) || (!T.data) || (!cam1intrinsics.data) || (!cam2intrinsics.data) || (!cam1distCoeffs.data) || (!cam2distCoeffs.data) )
{
cout << "Failed to load cameras calibration parameters" << endl;
help();
return -1;
}
size_t numberOfPatternImages = graycode->getNumberOfPatternImages();
vector<vector<Mat> > captured_pattern;
captured_pattern.resize( 2 );
captured_pattern[0].resize( numberOfPatternImages );
captured_pattern[1].resize( numberOfPatternImages );
Mat color = imread( imagelist[numberOfPatternImages], IMREAD_COLOR );
Size imagesSize = color.size();
// Stereo rectify
cout << "Rectifying images..." << endl;
Mat R1, R2, P1, P2, Q;
Rect validRoi[2];
stereoRectify( cam1intrinsics, cam1distCoeffs, cam2intrinsics, cam2distCoeffs, imagesSize, R, T, R1, R2, P1, P2, Q, 0,
-1, imagesSize, &validRoi[0], &validRoi[1] );
Mat map1x, map1y, map2x, map2y;
initUndistortRectifyMap( cam1intrinsics, cam1distCoeffs, R1, P1, imagesSize, CV_32FC1, map1x, map1y );
initUndistortRectifyMap( cam2intrinsics, cam2distCoeffs, R2, P2, imagesSize, CV_32FC1, map2x, map2y );
// Loading pattern images
for( size_t i = 0; i < numberOfPatternImages; i++ )
{
captured_pattern[0][i] = imread( imagelist[i], IMREAD_GRAYSCALE );
captured_pattern[1][i] = imread( imagelist[i + numberOfPatternImages + 2], IMREAD_GRAYSCALE );
if( (!captured_pattern[0][i].data) || (!captured_pattern[1][i].data) )
{
cout << "Empty images" << endl;
help();
return -1;
}
remap( captured_pattern[1][i], captured_pattern[1][i], map1x, map1y, INTER_NEAREST, BORDER_CONSTANT, Scalar() );
remap( captured_pattern[0][i], captured_pattern[0][i], map2x, map2y, INTER_NEAREST, BORDER_CONSTANT, Scalar() );
}
cout << "done" << endl;
vector<Mat> blackImages;
vector<Mat> whiteImages;
blackImages.resize( 2 );
whiteImages.resize( 2 );
// Loading images (all white + all black) needed for shadows computation
cvtColor( color, whiteImages[0], COLOR_RGB2GRAY );
whiteImages[1] = imread( imagelist[2 * numberOfPatternImages + 2], IMREAD_GRAYSCALE );
blackImages[0] = imread( imagelist[numberOfPatternImages + 1], IMREAD_GRAYSCALE );
blackImages[1] = imread( imagelist[2 * numberOfPatternImages + 2 + 1], IMREAD_GRAYSCALE );
remap( color, color, map2x, map2y, INTER_NEAREST, BORDER_CONSTANT, Scalar() );
remap( whiteImages[0], whiteImages[0], map2x, map2y, INTER_NEAREST, BORDER_CONSTANT, Scalar() );
remap( whiteImages[1], whiteImages[1], map1x, map1y, INTER_NEAREST, BORDER_CONSTANT, Scalar() );
remap( blackImages[0], blackImages[0], map2x, map2y, INTER_NEAREST, BORDER_CONSTANT, Scalar() );
remap( blackImages[1], blackImages[1], map1x, map1y, INTER_NEAREST, BORDER_CONSTANT, Scalar() );
cout << endl << "Decoding pattern ..." << endl;
```

--------------------------------

### Execute Installation

Source: https://docs.opencv.org/4.6.0/db/d05/tutorial_config_reference.html

Commands to install built binaries to the configured location, including options for elevated privileges and stripping symbols.

```bash
cmake --build . --target install
```

```bash
sudo cmake --build . --target install
```

```bash
cmake --build . --target install/strip
```

--------------------------------

### Setup and Run OpenCL Kernel

Source: https://docs.opencv.org/4.6.0/dd/d4c/classcv_1_1ocl_1_1Kernel.html

Demonstrates the use of the args method to bind multiple arguments to an OpenCL kernel before execution.

```cpp
bool ok = kernel
.args(
srcUMat, dstUMat,
(float)some_float_param
).run(ndims, globalSize, localSize);
if (!ok) return false;
```

--------------------------------

### setup

Source: https://docs.opencv.org/4.6.0/dc/d54/classcv_1_1bioinspired_1_1Retina.html

Configures the retina instance using a parameter file or object.

```APIDOC
## void setup(String retinaParameterFile="", const bool applyDefaultSetupOnFailure=true)

### Description
Try to open an XML retina parameters file to adjust the current retina instance setup.

### Parameters
- **retinaParameterFile** (String) - Optional - Path to the XML parameter file.
- **applyDefaultSetupOnFailure** (bool) - Optional - Whether to apply default settings if the file fails to load.
```

--------------------------------

### Point Usage Example

Source: https://docs.opencv.org/4.6.0/db/d4e/classcv_1_1Point__.html

Example demonstrating point arithmetic and coordinate access.

```cpp
Point2f a(0.3f, 0.f), b(0.f, 0.4f);
Point pt = (a + b)*10.f;
cout << pt.x << ", " << pt.y << endl;
```

--------------------------------

### Python Contour Detection Setup

Source: https://docs.opencv.org/4.6.0/df/d0d/tutorial_find_contours.html

Initial setup and callback function for contour detection in Python.

```python
from __future__ import print_function
import cv2 as cv
import numpy as np
import argparse
import random as rng
rng.seed(12345)
def thresh_callback(val):
threshold = val
```

--------------------------------

### Install OpenCV Prerequisites and Download Source

Source: https://docs.opencv.org/4.6.0/d7/d9f/tutorial_linux_install.html

Updates the package list and installs essential build tools, followed by downloading and extracting the OpenCV source code.

```bash
sudo apt update && sudo apt install -y cmake g++ wget unzip
```

```bash
wget -O opencv.zip https://github.com/opencv/opencv/archive/4.x.zip
unzip opencv.zip
```

--------------------------------

### Install Valgrind and Massif Visualizer

Source: https://docs.opencv.org/4.6.0/d3/d7a/tutorial_gapi_anisotropic_segmentation.html

Command to install the necessary profiling tools on Debian/Ubuntu systems.

```bash
$ sudo apt-get install valgrind massif-visualizer
```

--------------------------------

### Install Optional Dependencies

Source: https://docs.opencv.org/4.6.0/dd/dd5/tutorial_py_setup_in_fedora.html

Install additional libraries for extended format support, optimization, and documentation generation.

```bash
yum install libpng-devel
yum install libjpeg-turbo-devel
yum install jasper-devel
yum install openexr-devel
yum install libtiff-devel
yum install libwebp-devel
yum install tbb-devel
yum install eigen3-devel
yum install doxygen
```

--------------------------------

### Complete OpenCV.js integration example

Source: https://docs.opencv.org/4.6.0/d0/d84/tutorial_js_usage.html

A full example demonstrating image loading, processing, and memory management.

```html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Hello OpenCV.js</title>
</head>
<body>
<h2>Hello OpenCV.js</h2>
<p id="status">OpenCV.js is loading...</p>
<div>
<div class="inputoutput">
<img id="imageSrc" alt="No Image" />
<div class="caption">imageSrc <input type="file" id="fileInput" name="file" /></div>
</div>
<div class="inputoutput">
<canvas id="canvasOutput" ></canvas>
<div class="caption">canvasOutput</div>
</div>
</div>
<script type="text/javascript">
let imgElement = document.getElementById('imageSrc');
let inputElement = document.getElementById('fileInput');
inputElement.addEventListener('change', (e) => {
imgElement.src = URL.createObjectURL(e.target.files[0]);
}, false);
imgElement.onload = function() {
let mat = cv.imread(imgElement);
cv.imshow('canvasOutput', mat);
mat.delete();
};
var Module = {
// https://emscripten.org/docs/api_reference/module.html#Module.onRuntimeInitialized
onRuntimeInitialized() {
document.getElementById('status').innerHTML = 'OpenCV.js is ready.';
}
};
</script>
<script async src="opencv.js" type="text/javascript"></script>
</body>
</html>
```

--------------------------------

### Setup Virtual Environment

Source: https://docs.opencv.org/4.6.0/d1/d8f/tf_cls_tutorial_dnn_conversion.html

Commands to create and activate a Python 3.7+ virtual environment for the tutorial.

```bash
virtualenv -p /usr/bin/python3.7 <env_dir_path>
source <env_dir_path>/bin/activate
```

--------------------------------

### Install Optional Dependencies

Source: https://docs.opencv.org/4.6.0/d2/de6/tutorial_py_setup_in_ubuntu.html

Installs development files for various image format libraries to support additional file types.

```bash
sudo apt-get install libpng-dev
sudo apt-get install libjpeg-dev
sudo apt-get install libopenexr-dev
sudo apt-get install libtiff-dev
sudo apt-get install libwebp-dev
```

--------------------------------

### Install OpenCV on Linux

Source: https://docs.opencv.org/4.6.0/d6/d15/tutorial_building_tegra_cuda.html

Execute the installation command within the build directory. Root privileges may be required depending on the installation path.

```bash
$ make install
```

--------------------------------

### cv::ocl::Timer::start

Source: https://docs.opencv.org/4.6.0/df/d4a/classcv_1_1ocl_1_1Timer.html

Starts the timer.

```APIDOC
## void cv::ocl::Timer::start()

### Description
Begins the timing measurement.
```

--------------------------------

### Initialize Camera and Display Patterns

Source: https://docs.opencv.org/4.6.0/d0/de8/tutorial_capture_sinusoidal_pattern.html

Opens the camera and prepares the window for full-screen pattern projection.

```cpp
VideoCapture cap(CAP_PVAPI);
if( !cap.isOpened() )
{
cout << "Camera could not be opened" << endl;
return -1;
}
cap.set(CAP_PROP_PVAPI_PIXELFORMAT, CAP_PVAPI_PIXELFORMAT_MONO8);
namedWindow("pattern", WINDOW_NORMAL);
setWindowProperty("pattern", WND_PROP_FULLSCREEN, WINDOW_FULLSCREEN);
imshow("pattern", patterns[0]);
cout << "Press any key when ready" << endl;
waitKey(0);
```

--------------------------------

### Install Requirements

Source: https://docs.opencv.org/4.6.0/d1/d8f/tf_cls_tutorial_dnn_conversion.html

Command to install necessary dependencies from a requirements file.

```bash
pip install -r requirements.txt
```

--------------------------------

### Main Application Loop

Source: https://docs.opencv.org/4.6.0/d8/d34/samples_2cpp_2grabcut_8cpp-example.html

Initializes the window, sets up mouse callbacks, and handles user keyboard commands.

```cpp
GCApplication gcapp;
static void on_mouse( int event, int x, int y, int flags, void* param )
{
gcapp.mouseClick( event, x, y, flags, param );
}
int main( int argc, char** argv )
{
cv::CommandLineParser parser(argc, argv, "{@input| messi5.jpg |}");
help(argv);
string filename = parser.get<string>("@input");
if( filename.empty() )
{
cout << "\nDurn, empty filename" << endl;
return 1;
}
Mat image = imread(samples::findFile(filename), IMREAD_COLOR);
if( image.empty() )
{
cout << "\n Durn, couldn't read image filename " << filename << endl;
return 1;
}
const string winName = "image";
namedWindow( winName, WINDOW_AUTOSIZE );
setMouseCallback( winName, on_mouse, 0 );
gcapp.setImageAndWinName( image, winName );
gcapp.showImage();
for(;;)
{
char c = (char)waitKey(0);
switch( c )
{
case '\x1b':
cout << "Exiting ..." << endl;
goto exit_main;
case 'r':
cout << endl;
gcapp.reset();
gcapp.showImage();
break;
case 'n':
int iterCount = gcapp.getIterCount();
cout << "<" << iterCount << "... ";
int newIterCount = gcapp.nextIter();
if( newIterCount > iterCount )
{
gcapp.showImage();
cout << iterCount << ">" << endl;
}
else
cout << "rect must be determined>" << endl;
break;
}
}
exit_main:
destroyWindow( winName );
return 0;
}
```

--------------------------------

### Run the Retina Tutorial

Source: https://docs.opencv.org/4.6.0/d3/d86/tutorial_bioinspired_retina_model.html

Commands to execute the compiled retina tutorial on different media types.

```bash
./Retina_tuto -video
./Retina_tuto -video myVideo.avi
./Retina_tuto -image myPicture.jpg
./Retina_tuto -image myPicture.jpg log
```

--------------------------------

### Launching and Controlling a Viz3d Window

Source: https://docs.opencv.org/4.6.0/d5/d7d/tutorial_launching_viz.html

Complete example demonstrating window creation, event loop management, and window retrieval by name.

```cpp
#include <opencv2/viz.hpp>
#include <iostream>
using namespace cv;
using namespace std;
static void help()
{
cout
<< "--------------------------------------------------------------------------" << endl
<< "This program shows how to launch a 3D visualization window. You can stop event loop to continue executing. "
<< "You can access the same window via its name. You can run event loop for a given period of time. " << endl
<< "Usage:" << endl
<< "./launching_viz" << endl
<< endl;
}
int main()
{
help();
viz::Viz3d myWindow("Viz Demo");
myWindow.spin();
cout << "First event loop is over" << endl;
viz::Viz3d sameWindow = viz::getWindowByName("Viz Demo");
sameWindow.spin();
cout << "Second event loop is over" << endl;
sameWindow.spinOnce(1, true);
while(!sameWindow.wasStopped())
{
sameWindow.spinOnce(1, true);
}
cout << "Last event loop is over" << endl;
return 0;
}
```

--------------------------------

### Install OpenCV-Python via Yum

Source: https://docs.opencv.org/4.6.0/dd/dd5/tutorial_py_setup_in_fedora.html

Install pre-built OpenCV packages using the yum package manager.

```bash
yum install numpy opencv*
```

--------------------------------

### OpenCV.js Environment Setup Functions

Source: https://docs.opencv.org/4.6.0/dc/de6/tutorial_js_nodejs.html

Helper functions to load OpenCV.js, mount local directories to the Emscripten filesystem, and emulate the DOM.

```javascript
function loadOpenCV(rootDir = '/work', localRootDir = process.cwd()) {
if(global.Module && global.Module.onRuntimeInitialized && global.cv && global.cv.imread) {
return Promise.resolve()
}
return new Promise(resolve => {
installDOM()
global.Module = {
onRuntimeInitialized() {
// We change emscripten current work directory to 'rootDir' so relative paths are resolved
// relative to the current local folder, as expected
cv.FS.chdir(rootDir)
resolve()
},
preRun() {
// preRun() is another callback like onRuntimeInitialized() but is called just before the
// library code runs. Here we mount a local folder in emscripten filesystem and we want to
// do this before the library is executed so the filesystem is accessible from the start
const FS = global.Module.FS
// create rootDir if it doesn't exists
if(!FS.analyzePath(rootDir).exists) {
FS.mkdir(rootDir);
}
// create localRootFolder if it doesn't exists
if(!existsSync(localRootDir)) {
mkdirSync(localRootDir, { recursive: true});
}
// FS.mount() is similar to Linux/POSIX mount operation. It basically mounts an external
// filesystem with given format, in given current filesystem directory.
FS.mount(FS.filesystems.NODEFS, { root: localRootDir}, rootDir);
}
};
global.cv = require('./opencv.js')
});
}
function installDOM(){
const dom = new JSDOM();
global.document = dom.window.document;
global.Image = Image;
global.HTMLCanvasElement = Canvas;
global.ImageData = ImageData;
global.HTMLImageElement = Image;
}
```

--------------------------------

### Install OpenCV Dependencies

Source: https://docs.opencv.org/4.6.0/d6/d15/tutorial_building_tegra_cuda.html

Command to install the required development packages for building OpenCV.

```bash
$ sudo apt-get install \
    libglew-dev \
    libtiff5-dev \
    zlib1g-dev \
    libjpeg-dev \
    libpng12-dev \
    libjasper-dev \
    libavcodec-dev \
    libavformat-dev \
    libavutil-dev \
    libpostproc-dev \
    libswscale-dev \
    libeigen3-dev \
    libtbb-dev \
    libgtk2.0-dev \
    pkg-config
```

--------------------------------

### Install Pylint

Source: https://docs.opencv.org/4.6.0/d4/db1/tutorial_documentation.html

Command to install the Pylint dependency required for Python code testing.

```bash
pip install pylint
```

--------------------------------

### CommandLineParser Usage Example

Source: https://docs.opencv.org/4.6.0/d0/d2e/classcv_1_1CommandLineParser.html

Demonstrates initializing the parser, checking for flags, retrieving typed arguments, and validating the parsing process.

```cpp
CommandLineParser parser(argc, argv, keys);
parser.about("Application name v1.0.0");
if (parser.has("help"))
{
parser.printMessage();
return 0;
}
int N = parser.get<int>("N");
double fps = parser.get<double>("fps");
String path = parser.get<String>("path");
use_time_stamp = parser.has("timestamp");
String img1 = parser.get<String>(0);
String img2 = parser.get<String>(1);
int repeat = parser.get<int>(2);
if (!parser.check())
{
parser.printErrors();
return 0;
}
```

--------------------------------

### Verify OpenCV Installation

Source: https://docs.opencv.org/4.6.0/d2/de6/tutorial_py_setup_in_ubuntu.html

Checks if the OpenCV library is correctly installed and accessible in Python.

```python
import cv2 as cv
print(cv.__version__)
```

--------------------------------

### Setup Visualization Window

Source: https://docs.opencv.org/4.6.0/d1/d1d/tutorial_histo3D.html

Initializes the OpenCV window with a trackbar and the Viz 3D window.

```cpp
namedWindow("Image");
imshow("Image",img);
AddSlidebar("threshold","Image",0,100,h.seuil,&h.seuil, UpdateThreshold,&h);
waitKey(30);
h.fen3D = makePtr<viz::Viz3d>("3D Histogram");
h.nbWidget=0;
h.fen3D->registerKeyboardCallback(KeyboardViz3d,&h);
DrawHistogram3D(h);
while (h.code!=27)
{
h.fen3D->spinOnce(1);
if (h.status)
DrawHistogram3D(h);
if (h.code!=27)
h.code= waitKey(30);
}
```

--------------------------------

### Hit-or-Miss Transformation Examples

Source: https://docs.opencv.org/4.6.0/db/d06/tutorial_hitOrMiss.html

Examples demonstrating the Hit-or-Miss transformation in C++, Java, and Python.

```cpp
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
using namespace cv;
int main(){
Mat input_image = (Mat_<uchar>(8, 8) <<
0, 0, 0, 0, 0, 0, 0, 0,
0, 255, 255, 255, 0, 0, 0, 255,
0, 255, 255, 255, 0, 0, 0, 0,
0, 255, 255, 255, 0, 255, 0, 0,
0, 0, 255, 0, 0, 0, 0, 0,
0, 0, 255, 0, 0, 255, 255, 0,
0, 255, 0, 255, 0, 0, 255, 0,
0, 255, 255, 255, 0, 0, 0, 0);
Mat kernel = (Mat_<int>(3, 3) <<
0, 1, 0,
1, -1, 1,
0, 1, 0);
Mat output_image;
morphologyEx(input_image, output_image, MORPH_HITMISS, kernel);
const int rate = 50;
kernel = (kernel + 1) * 127;
kernel.convertTo(kernel, CV_8U);
resize(kernel, kernel, Size(), rate, rate, INTER_NEAREST);
imshow("kernel", kernel);
moveWindow("kernel", 0, 0);
resize(input_image, input_image, Size(), rate, rate, INTER_NEAREST);
imshow("Original", input_image);
moveWindow("Original", 0, 200);
resize(output_image, output_image, Size(), rate, rate, INTER_NEAREST);
imshow("Hit or Miss", output_image);
moveWindow("Hit or Miss", 500, 200);
waitKey(0);
return 0;
}
```

```java
import org.opencv.core.*;
import org.opencv.highgui.HighGui;
import org.opencv.imgproc.Imgproc;
class HitMissRun{
public void run() {
Mat input_image = new Mat( 8, 8, CvType.CV_8UC1 );
int row = 0, col = 0;
input_image.put(row ,col,
0, 0, 0, 0, 0, 0, 0, 0,
0, 255, 255, 255, 0, 0, 0, 255,
0, 255, 255, 255, 0, 0, 0, 0,
0, 255, 255, 255, 0, 255, 0, 0,
0, 0, 255, 0, 0, 0, 0, 0,
0, 0, 255, 0, 0, 255, 255, 0,
0, 255, 0, 255, 0, 0, 255, 0,
0, 255, 255, 255, 0, 0, 0, 0);
Mat kernel = new Mat( 3, 3, CvType.CV_16S );
kernel.put(row ,col,
0, 1, 0,
1, -1, 1,
0, 1, 0 );
Mat output_image = new Mat();
Imgproc.morphologyEx(input_image, output_image, Imgproc.MORPH_HITMISS, kernel);
int rate = 50;
Core.add(kernel, new Scalar(1), kernel);
Core.multiply(kernel, new Scalar(127), kernel);
kernel.convertTo(kernel, CvType.CV_8U);
Imgproc.resize(kernel, kernel, new Size(), rate, rate, Imgproc.INTER_NEAREST);
HighGui.imshow("kernel", kernel);
HighGui.moveWindow("kernel", 0, 0);
Imgproc.resize(input_image, input_image, new Size(), rate, rate, Imgproc.INTER_NEAREST);
HighGui.imshow("Original", input_image);
HighGui.moveWindow("Original", 0, 200);
Imgproc.resize(output_image, output_image, new Size(), rate, rate, Imgproc.INTER_NEAREST);
HighGui.imshow("Hit or Miss", output_image);
HighGui.moveWindow("Hit or Miss", 500, 200);
HighGui.waitKey(0);
System.exit(0);
}
}
public class HitMiss
{
public static void main(String[] args) {
// load the native OpenCV library
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
new HitMissRun().run();
}
}
```

```python
import cv2 as cv
import numpy as np
input_image = np.array((
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 255, 255, 255, 0, 0, 0, 255],
[0, 255, 255, 255, 0, 0, 0, 0],
[0, 255, 255, 255, 0, 255, 0, 0],
[0, 0, 255, 0, 0, 0, 0, 0],
[0, 0, 255, 0, 0, 255, 255, 0],
[0,255, 0, 255, 0, 0, 255, 0],
[0, 255, 255, 255, 0, 0, 0, 0]), dtype="uint8")
kernel = np.array((
[0, 1, 0],
[1, -1, 1],
[0, 1, 0]), dtype="int")
output_image = cv.morphologyEx(input_image, cv.MORPH_HITMISS, kernel)
rate = 50
kernel = (kernel + 1) * 127
kernel = np.uint8(kernel)
kernel = cv.resize(kernel, None, fx = rate, fy = rate, interpolation = cv.INTER_NEAREST)
cv.imshow("kernel", kernel)
cv.moveWindow("kernel", 0, 0)
input_image = cv.resize(input_image, None, fx = rate, fy = rate, interpolation = cv.INTER_NEAREST)
cv.imshow("Original", input_image)
cv.moveWindow("Original", 0, 200)
output_image = cv.resize(output_image, None , fx = rate, fy = rate, interpolation = cv.INTER_NEAREST)
cv.imshow("Hit or Miss", output_image)
cv.moveWindow("Hit or Miss", 500, 200)
cv.waitKey(0)
cv.destroyAllWindows()
```

--------------------------------

### Start Camera Action

Source: https://docs.opencv.org/4.6.0/db/dc8/tutorial_video_processing.html

Trigger the camera start process via a button action.

```objective-c
#pragma mark - UI Actions
- (IBAction)actionStart:(id)sender;
{
[self.videoCamera start];
}
```

--------------------------------

### Initialize OpenCV Matrices

Source: https://docs.opencv.org/4.6.0/d1/dfb/intro.html

Examples of creating matrices with specific types and channel configurations.

```cpp
Mat mtx(3, 3, CV_32F); // make a 3x3 floating-point matrix
Mat cmtx(10, 1, CV_64FC2); // make a 10x1 2-channel floating-point
// matrix (10-element complex vector)
Mat img(Size(1920, 1080), CV_8UC3); // make a 3-channel (color) image
// of 1920 columns and 1080 rows.
Mat grayscale(image.size(), CV_MAKETYPE(image.depth(), 1)); // make a 1-channel image of
// the same size and same
// channel type as img
```

--------------------------------

### Build Qt

Source: https://docs.opencv.org/4.6.0/d3/d52/tutorial_windows_install.html

Execute the build process for Qt using nmake.

```batch
nmake
```

--------------------------------

### Build and Install Ceres Solver

Source: https://docs.opencv.org/4.6.0/db/db8/tutorial_sfm_installation.html

Clone, build, test, and install the Ceres Solver from source.

```bash
git clone https://ceres-solver.googlesource.com/ceres-solver
cd ceres-solver
mkdir build && cd build
cmake ..
make -j4
make test
sudo make install
```

--------------------------------

### Install SfM Required Dependencies

Source: https://docs.opencv.org/4.6.0/db/db8/tutorial_sfm_installation.html

Install Eigen, GFlags, and GLog libraries on Ubuntu systems.

```bash
sudo apt-get install libeigen3-dev libgflags-dev libgoogle-glog-dev
```

--------------------------------

### Initialize Main Program

Source: https://docs.opencv.org/4.6.0/d3/d86/tutorial_bioinspired_retina_model.html

Main function entry point declaring input buffer and video capture objects.

```cpp
int main(int argc, char* argv[]) {
// declare the retina input buffer... that will be fed differently in regard of the input media
cv::Mat inputFrame;
cv::VideoCapture videoCapture; // in case a video media is used, its manager is declared here
```

--------------------------------

### Configure Installation Prefix

Source: https://docs.opencv.org/4.6.0/db/d05/tutorial_config_reference.html

Sets the root directory for OpenCV installation using the CMAKE_INSTALL_PREFIX flag.

```bash
cmake -DCMAKE_INSTALL_PREFIX=/opt/opencv ../opencv
```

```bash
cmake -DCMAKE_INSTALL_PREFIX=install ../opencv
```

--------------------------------

### Initialize Thresholding Demo

Source: https://docs.opencv.org/4.6.0/db/d8e/tutorial_threshold.html

Setup code for the thresholding demonstration including trackbar creation and initial function call.

```python
src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
cv.namedWindow(window_name)
cv.createTrackbar(trackbar_type, window_name , 3, max_type, Threshold_Demo)
# Create Trackbar to choose Threshold value
cv.createTrackbar(trackbar_value, window_name , 0, max_value, Threshold_Demo)
# Call the function to initialize
Threshold_Demo(0)
# Wait until user finishes program
cv.waitKey()
```

--------------------------------

### Install CxxWrap via Julia REPL

Source: https://docs.opencv.org/4.6.0/d8/da4/tutorial_julia.html

Install the CxxWrap package required for building the bindings.

```julia
pkg> add CxxWrap
```

--------------------------------

### Initialize Qt GUI components

Source: https://docs.opencv.org/4.6.0/dc/d46/group__highgui__qt.html

Demonstrates creating windows, trackbars, and buttons within the Qt GUI environment.

```cpp
int main(int argc, char *argv[])
{
int value = 50;
int value2 = 0;
namedWindow("main1",WINDOW_NORMAL);
namedWindow("main2",WINDOW_AUTOSIZE | WINDOW_GUI_NORMAL);
createTrackbar( "track1", "main1", &value, 255, NULL);
String nameb1 = "button1";
String nameb2 = "button2";
createButton(nameb1,callbackButton,&nameb1,QT_CHECKBOX,1);
createButton(nameb2,callbackButton,NULL,QT_CHECKBOX,0);
createTrackbar( "track2", NULL, &value2, 255, NULL);
createButton("button5",callbackButton1,NULL,QT_RADIOBOX,0);
createButton("button6",callbackButton2,NULL,QT_RADIOBOX,1);
setMouseCallback( "main2",on_mouse,NULL );
Mat img1 = imread("files/flower.jpg");
VideoCapture video;
video.open("files/hockey.avi");
Mat img2,img3;
while( waitKey(33) != 27 )
{
img1.convertTo(img2,-1,1,value);
video >> img3;
imshow("main1",img2);
imshow("main2",img3);
}
destroyAllWindows();
return 0;
}
```

--------------------------------

### Initialize ORB and Load Image

Source: https://docs.opencv.org/4.6.0/d1/d89/tutorial_py_orb.html

Basic setup for using ORB, including importing necessary libraries and loading an image in grayscale.

```python
import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('simple.jpg',0)
```

--------------------------------

### Install Specific Emscripten Version

Source: https://docs.opencv.org/4.6.0/d4/da1/tutorial_js_setup.html

Commands to install and activate a specific verified version of Emscripten.

```bash
./emsdk update
./emsdk install 2.0.10
./emsdk activate 2.0.10
```

--------------------------------

### Select VideoCapture Backend at Runtime

Source: https://docs.opencv.org/4.6.0/d0/da7/videoio_overview.html

Examples of specifying a backend API when initializing or opening a video capture object.

```cpp
//declare a capture object
cv::VideoCapture cap(0, cv::CAP_MSMF);
//or specify the apiPreference with open
cap.open(0, cv::CAP_MSMF);
```

```cpp
//declare a capture object
cv::VideoCapture cap(filename, cv::CAP_MSMF);
//or specify the apiPreference with open
cap.open(filename, cv::CAP_MSMF);
```

--------------------------------

### Load Image and Setup Trackbar

Source: https://docs.opencv.org/4.6.0/df/d0d/tutorial_find_contours.html

Loads an image, converts it to grayscale, and initializes a trackbar for threshold adjustment.

```python
# Load source image
parser = argparse.ArgumentParser(description='Code for Finding contours in your image tutorial.')
parser.add_argument('--input', help='Path to input image.', default='HappyFish.jpg')
args = parser.parse_args()
src = cv.imread(cv.samples.findFile(args.input))
if src is None:
print('Could not open or find the image:', args.input)
exit(0)
# Convert image to gray and blur it
src_gray = cv.cvtColor(src, cv.COLOR_BGR2GRAY)
src_gray = cv.blur(src_gray, (3,3))
# Create Window
source_window = 'Source'
cv.namedWindow(source_window)
cv.imshow(source_window, src)
max_thresh = 255
thresh = 100 # initial threshold
cv.createTrackbar('Canny Thresh:', source_window, thresh, max_thresh, thresh_callback)
thresh_callback(thresh)
cv.waitKey()
```

--------------------------------

### Run Detection with Parameters

Source: https://docs.opencv.org/4.6.0/dc/d2c/tutorial_real_time_pose.html

Example command-line execution for configuring the ratio threshold, keypoint count, and matching mode.

```bash
./cpp-tutorial-pnp_detection --ratio=0.8 --keypoints=1000 --fast=false
```

--------------------------------

### Morphological Line Detection Setup in Python

Source: https://docs.opencv.org/4.6.0/dd/dd7/tutorial_morph_lines_detection.html

Initializes the environment and helper functions for morphological line detection in Python.

```python
"""
@file morph_lines_detection.py
@brief Use morphology transformations for extracting horizontal and vertical lines sample code
"""
import numpy as np
import sys
import cv2 as cv
def show_wait_destroy(winname, img):
cv.imshow(winname, img)
cv.moveWindow(winname, 500, 0)
cv.waitKey(0)
cv.destroyWindow(winname)
def main(argv):
```

--------------------------------

### Create KeyPoint dataset with fixed size

Source: https://docs.opencv.org/4.6.0/d3/d23/classcv_1_1hdf_1_1HDF5.html

Example demonstrating how to create a fixed-size dataset for 100 keypoints in an HDF5 file.

```cpp
// open hdf5 file
cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( "mytest.h5" );
if ( ! h5io->hlexists( "keypoints" ) )
h5io->kpcreate( 100, "keypoints" );
else
printf("DS already created, skipping\n" );
```

--------------------------------

### printSetup

Source: https://docs.opencv.org/4.6.0/dc/d54/classcv_1_1bioinspired_1_1Retina.html

Outputs a string showing the current parameters setup of the retina module.

```APIDOC
## printSetup()

### Description
Outputs a string showing the used parameters setup.

### Returns
- **retval** (String) - A string which contains formatted parameters information.
```

--------------------------------

### Install and Activate Emscripten SDK

Source: https://docs.opencv.org/4.6.0/d4/da1/tutorial_js_setup.html

Commands to update, install, and activate the latest version of the Emscripten SDK.

```bash
./emsdk update
./emsdk install latest
./emsdk activate latest
```

--------------------------------

### Intelligent Scissors Usage Example

Source: https://docs.opencv.org/4.6.0/df/d6b/classcv_1_1segmentation_1_1IntelligentScissorsMB.html

Demonstrates the basic workflow of initializing the tool, setting parameters, applying an image, and extracting a contour.

```cpp
segmentation::IntelligentScissorsMB tool;
tool.setEdgeFeatureCannyParameters(16, 100) // using Canny() as edge feature extractor
.setGradientMagnitudeMaxLimit(200);
// calculate image features
tool.applyImage(image);
// calculate map for specified source point
Point source_point(200, 100);
tool.buildMap(source_point);
// fast fetching of contours
// for specified target point and the pre-calculated map (stored internally)
Point target_point(400, 300);
std::vector<Point> pts;
tool.getContour(target_point, pts);
```

--------------------------------

### Install Build Dependencies

Source: https://docs.opencv.org/4.6.0/d2/de6/tutorial_py_setup_in_ubuntu.html

Commands to install required build tools and libraries for compiling OpenCV from source.

```bash
sudo apt-get install cmake
sudo apt-get install gcc g++
to support python2:
sudo apt-get install python-dev python-numpy
to support python3:
sudo apt-get install python3-dev python3-numpy

sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev
sudo apt-get install libgstreamer-plugins-base1.0-dev libgstreamer1.0-dev
to support gtk2: 
sudo apt-get install libgtk2.0-dev
to support gtk3: 
sudo apt-get install libgtk-3-dev
```

--------------------------------

### Initialize Network

Source: https://docs.opencv.org/4.6.0/d5/de7/tutorial_dnn_googlenet.html

Reads the network configuration and model files, then sets the preferred backend and target.

```cpp
Net net = readNet(model, config, framework);
net.setPreferableBackend(backendId);
net.setPreferableTarget(targetId);
```

--------------------------------

### Install OpenCV-Python via apt

Source: https://docs.opencv.org/4.6.0/d2/de6/tutorial_py_setup_in_ubuntu.html

Installs the pre-built OpenCV package using the system package manager.

```bash
$ sudo apt-get install python3-opencv
```

--------------------------------

### Use matrix initializers

Source: https://docs.opencv.org/4.6.0/d3/d63/classcv_1_1Mat.html

Demonstrates identity matrix creation and comma-separated initialization syntax.

```cpp
// create a double-precision identity matrix and add it to M.
M += Mat::eye(M.rows, M.cols, CV_64F);
```

```cpp
// create a 3x3 double-precision identity matrix
Mat M = (Mat_<double>(3,3) << 1, 0, 0, 0, 1, 0, 0, 0, 1);
```

--------------------------------

### Install CMake via Homebrew

Source: https://docs.opencv.org/4.6.0/d0/db2/tutorial_macos_install.html

Alternative method to install CMake using the Homebrew package manager.

```bash
brew install cmake
```

--------------------------------

### Install ARM cross-compilation tools

Source: https://docs.opencv.org/4.6.0/d0/d76/tutorial_arm_crosscompile_with_cmake.html

Commands to install the necessary GCC cross-compilation toolchains for ARM on Ubuntu.

```bash
sudo apt-get install gcc-arm-linux-gnueabi
```

```bash
sudo apt-get install gcc-arm-linux-gnueabihf
```

--------------------------------

### setup

Source: https://docs.opencv.org/4.6.0/dd/d73/classcv_1_1bioinspired_1_1RetinaFastToneMapping.html

Updates tone mapping behaviors by adjusting the local luminance computation area.

```APIDOC
## void setup(const float photoreceptorsNeighborhoodRadius=3.f, const float ganglioncellsNeighborhoodRadius=1.f, const float meanLuminanceModulatorK=1.f)

### Description
Updates tone mapping behaviors by adjusting the local luminance computation area.

### Parameters
- **photoreceptorsNeighborhoodRadius** (float) - Optional. The radius of the photoreceptors neighborhood.
- **ganglioncellsNeighborhoodRadius** (float) - Optional. The radius of the ganglion cells neighborhood.
- **meanLuminanceModulatorK** (float) - Optional. The mean luminance modulator constant.
```

--------------------------------

### Create unlimited KeyPoint dataset

Source: https://docs.opencv.org/4.6.0/d3/d23/classcv_1_1hdf_1_1HDF5.html

Example demonstrating how to create an unlimited-size dataset for keypoints with custom chunking.

```cpp
// open hdf5 file
cv::Ptr<cv::hdf::HDF5> h5io = cv::hdf::open( "mytest.h5" );
if ( ! h5io->hlexists( "keypoints" ) )
h5io->kpcreate( cv::hdf::HDF5::H5_UNLIMITED, "keypoints", cv::hdf::HDF5::H5_NONE, 100 );
else
printf("DS already created, skipping\n" );
```

--------------------------------

### OpenCV File Storage Examples

Source: https://docs.opencv.org/4.6.0/d2/d75/namespacecv.html

Examples of a 3x3 identity matrix stored in XML and YAML formats.

```xml
<?xml version="1.0">
<opencv_storage>
<A type_id="opencv-matrix">
<rows>3</rows>
<cols>3</cols>
<dt>f</dt>
<data>1. 0. 0. 0. 1. 0. 0. 0. 1.</data>
</A>
</opencv_storage>
```

```yaml
%YAML:1.0
A: !!opencv-matrix
rows: 3
cols: 3
dt: f
data: [ 1., 0., 0., 0., 1., 0., 0., 0., 1.]
```

--------------------------------

### Initialize Corner Detection in Python

Source: https://docs.opencv.org/4.6.0/dd/d92/tutorial_corner_subpixels.html

Sets up the environment and initial parameters for the corner detection demonstration.

```python
from __future__ import print_function
import cv2 as cv
import numpy as np
import argparse
import random as rng
source_window = 'Image'
maxTrackbar = 25
rng.seed(12345)
def goodFeaturesToTrack_Demo(val):
maxCorners = max(val, 1)
```

--------------------------------

### OpenCV Backprojection Setup

Source: https://docs.opencv.org/4.6.0/dc/df6/tutorial_py_histogram_backprojection.html

Initializes the ROI and target images in HSV color space for use with cv.calcBackProject.

```python
import numpy as np
import cv2 as cv
roi = cv.imread('rose_red.png')
hsv = cv.cvtColor(roi,cv.COLOR_BGR2HSV)
target = cv.imread('rose.png')
hsvt = cv.cvtColor(target,cv.COLOR_BGR2HSV)
```

--------------------------------

### Initialize Image Blending with Pyramids

Source: https://docs.opencv.org/4.6.0/dc/dff/tutorial_py_pyramids.html

Setup code for loading images to perform pyramid-based blending.

```python
import cv2 as cv
import numpy as np,sys
A = cv.imread('apple.jpg')
B = cv.imread('orange.jpg')
```

--------------------------------

### Full Tracking Implementation

Source: https://docs.opencv.org/4.6.0/d2/d0a/tutorial_introduction_to_tracker.html

A complete C++ example demonstrating how to initialize a KCF tracker, select an ROI, and process video frames to track an object.

```cpp
#include <opencv2/core/utility.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/tracking.hpp>
#include <opencv2/videoio.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <cstring>
using namespace std;
using namespace cv;
int main( int argc, char** argv ){
// show help
if(argc<2){
cout<<
" Usage: tracker <video_name>\n"
" examples:\n"
" example_tracking_kcf Bolt/img/%04d.jpg\n"
" example_tracking_kcf faceocc2.webm\n"
<< endl;
return 0;
}
// declares all required variables
Rect roi;
Mat frame;
// create a tracker object
Ptr<Tracker> tracker = TrackerKCF::create();
// set input video
std::string video = argv[1];
VideoCapture cap(video);
// get bounding box
cap >> frame;
roi=selectROI("tracker",frame);
//quit if ROI was not selected
if(roi.width==0 || roi.height==0)
return 0;
// initialize the tracker
tracker->init(frame,roi);
// perform the tracking process
printf("Start the tracking process, press ESC to quit.\n");
for ( ;; ){
// get frame from the video
cap >> frame;
// stop the program if no more images
if(frame.rows==0 || frame.cols==0)
break;
// update the tracking result
tracker->update(frame,roi);
// draw the tracked object
rectangle( frame, roi, Scalar( 255, 0, 0 ), 2, 1 );
// show image with the tracked object
imshow("tracker",frame);
//quit on ESC button
if(waitKey(1)==27)break;
}
return 0;
}
```
Tokens:
Raw