OpenCV

https://docs.opencv.org/5.0
Admin
OpenCV (Open Source Computer Vision Library) is an open-source library that includes several...
Tokens:4,867,213
Snippets:34,361
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Set up Node.js project and install jimp

Source: https://docs.opencv.org/5.0/js_tutorials/js_setup/js_nodejs/js_nodejs.html

Run these commands in a terminal to create a new Node.js package and install the jimp dependency. This is the required setup before running the example.

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

```

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

### Quick start: create virtual environment and install OpenCV with pip

Source: https://docs.opencv.org/5.0/py_tutorials/py_setup/py_pip_install/py_pip_install.html

Recommended setup for most users. Creates and activates a virtual environment, upgrades pip tooling, and installs one of the OpenCV PyPI variants. Choose exactly one of the four pip install commands.

```bash
# 1) Create and activate a virtual environment (recommended)
python -m venv .venv
# Windows:
.venv\Scripts\activate
# Linux/macOS:
source .venv/bin/activate

# 2) Upgrade pip tooling
python -m pip install --upgrade pip setuptools wheel

# 3) Install OpenCV from PyPI (choose ONE)
pip install opencv-python          # main package (most users)
# or
pip install opencv-contrib-python  # + extra modules (contrib)
# or
pip install opencv-python-headless # no GUI/backends (servers/CI)
# or
pip install opencv-contrib-python-headless # no GUI/backends with extra modules (servers/CI)

```

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

### Build core modules with CMake and Ninja

Source: https://docs.opencv.org/5.0/tutorials/introduction/linux_install/linux_install.html

Quick start commands to install prerequisites, download OpenCV 5.x sources, configure with CMake using Ninja, and build the core modules. Run these commands in a terminal on Ubuntu 18.04 or similar.

```bash
# Install minimal prerequisites (Ubuntu 18.04 as reference)
sudo apt update && sudo apt install -y cmake g++ wget unzip ninja-build

# Download and unpack sources
wget -O opencv.zip https://github.com/opencv/opencv/archive/5.x.zip
unzip opencv.zip

# Create build directory
mkdir -p build && cd build

# Configure
cmake -GNinja  ../opencv-5.x

# Build
cmake --build .

```

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

### Build and install OpenCV with make

Source: https://docs.opencv.org/5.0/py_tutorials/py_setup/py_setup_in_ubuntu/py_setup_in_ubuntu.html

Compile the source with 'make' and install with 'sudo make install'.

```bash
$ make
# sudo make install

```

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

### Setup OpenCL kernel arguments with args() and run()

Source: https://docs.opencv.org/5.0/main_modules/classcv_1_1ocl_1_1Kernel.html

Sets up OpenCL kernel arguments using the args() method and runs the kernel. The args() method is preferred over direct set() calls. The run() call may adjust the global size; the boolean return value indicates success, and the example returns false on failure.

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

```

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

### Install OpenCV on Mac OS X

Source: https://docs.opencv.org/5.0/tutorials/introduction/clojure_dev_intro/clojure_dev_intro.html

Quick start guide to install OpenCV on Mac OS X, assuming xcode, jdk, and Cmake are already installed. Builds OpenCV with shared libraries disabled and optionally installs it.

```bash
cd ~/
mkdir opt
git clone https://github.com/opencv/opencv.git
cd opencv
git checkout 2.4
mkdir build
cd build
cmake -DBUILD_SHARED_LIBS=OFF ..
...
...
make -j8
## optional
## make install

```

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

### setup()

Source: https://docs.opencv.org/5.0/extra_modules/classcv_1_1bioinspired_1_1TransientAreasSegmentationModule.html

Sets up the module with default parameters.

```APIDOC
## setup()

### Description
Sets up the module with default parameters.

### Method
setup

### Signature
void setup()

### Parameters
None

### Returns
None
```

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

### setup()

Source: https://docs.opencv.org/5.0/extra_modules/classcv_1_1bioinspired_1_1TransientAreasSegmentationModule.html

Sets up the module with individual parameters.

```APIDOC
## setup()

### Description
Sets up the module with individual parameters.

### Method
setup

### Signature
void setup(const Size& size, int transientAreasThreshold, int noiseLevel)

### Parameters
- **size** (Size) - Size of the input images.
- **transientAreasThreshold** (int) - Threshold for transient areas.
- **noiseLevel** (int) - Noise level.

### Returns
None
```

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

### setup()

Source: https://docs.opencv.org/5.0/extra_modules/classcv_1_1bioinspired_1_1TransientAreasSegmentationModule.html

Sets up the module with the given parameters.

```APIDOC
## setup()

### Description
Sets up the module with the given parameters.

### Method
setup

### Signature
void setup(const Params& params)

### Parameters
- **params** (Params) - Parameters for the module.

### Returns
None
```

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

### Start application to get path

Source: https://docs.opencv.org/5.0/main_modules/classcv_1_1CommandLineParser.html

Shows the command used to start the application, from which getPathToApplication() returns the directory.

```bash
$ ./bin/my-executable
```

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

### Build the example project

Source: https://docs.opencv.org/5.0/tutorials/introduction/windows_msys2_vscode/window_install_opencv.html

Creates a build directory, configures with CMake, and builds the example project.

```bash
mkdir build && cd build
cmake -G "MinGW Makefiles" ..
mingw32-make

```

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

### Install git for cloning repository

Source: https://docs.opencv.org/5.0/tutorials/introduction/linux_install/linux_install.html

Installs git, an alternative tool for getting the OpenCV sources via cloning the repository.

```bash
sudo apt install -y git

```

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

### printSetup()

Source: https://docs.opencv.org/5.0/extra_modules/classcv_1_1bioinspired_1_1TransientAreasSegmentationModule.html

Displays the parameters setup and returns a formatted string.

```APIDOC
## printSetup()

### Description
Parameters setup display method. Returns a string which contains formatted parameters information.

### Method
printSetup

### Signature
`String cv::bioinspired::TransientAreasSegmentationModule::printSetup()`

### Python
```
cv.bioinspired.TransientAreasSegmentationModule.printSetup() -> retval
```

### Parameters
None

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

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

### Example build configuration

Source: https://docs.opencv.org/5.0/tutorials/introduction/crosscompilation/arm_crosscompile_with_cmake.html

Example commands to create a build directory and run CMake with the toolchain file.

```bash
cd ~/opencv/platforms/linux
mkdir -p build_hardfp
cd build_hardfp

cmake -DCMAKE_TOOLCHAIN_FILE=../arm-gnueabi.toolchain.cmake ../../..

```

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

### Install optional image format development libraries

Source: https://docs.opencv.org/5.0/py_tutorials/py_setup/py_setup_in_fedora/py_setup_in_fedora.html

Install development files for PNG, JPEG, JPEG2000, TIFF, WebP, and other image formats to get latest libraries.

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

```

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

### Install CxxWrap.jl package

Source: https://docs.opencv.org/5.0/tutorials_contrib/julia/julia.html

Installs the CxxWrap.jl package, a prerequisite for building the Julia bindings. Start the Julia REPL, press `]` to enter package mode, then run `add CxxWrap`.

```julia
$ julia
...
julia> ]
pkg> add CxxWrap

```

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

### setUp()

Source: https://docs.opencv.org/5.0/extra_modules/classcv_1_1videostab_1_1OnePassStabilizer.html

Sets up the stabilizer with the first frame.

```APIDOC
## setUp()

### Description
Sets up the stabilizer with the first frame.

### Method
Member function

### Signature
`void cv::videostab::OnePassStabilizer::setUp(const Mat &firstFrame)`

### Parameters
- **firstFrame** (const Mat&) - Required - The first frame of the video.

### Returns
None.
```

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

### Pointer Setup and Kernel Loop Start

Source: https://docs.opencv.org/5.0/tutorials/core/univ_intrin/univ_intrin.html

Declares pointers to source and kernel, and starts the loop over kernel elements. The vector lane count is obtained from VTraits<v_float32x4>::vlanes().

```cpp
int step = VTraits<v_float32x4>::vlanes();
float *sptr = src_32.ptr<float>(row), *kptr = kernel.ptr<float>(rowk);
for (int k = 0; k < ksize; k++)
{

```

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

### Install OpenCV Julia package

Source: https://docs.opencv.org/5.0/tutorials_contrib/julia/julia.html

Installs the OpenCV package for Julia using the built-in package manager. Start the Julia REPL, press `]` to enter package mode, then run `add OpenCV`.

```julia
$ julia
...
julia> ]
pkg> add OpenCV

```

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

### Run example1.js with node

Source: https://docs.opencv.org/5.0/js_tutorials/js_setup/js_nodejs/js_nodejs.html

Executes the minimal example. The command should print OpenCV build information.

```bash
node example1.js

```

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

### Quatd getAxis() example

Source: https://docs.opencv.org/5.0/main_modules/classcv_1_1Quat.html

Shows two ways to get the rotation axis: directly and with QUAT_ASSUME_UNIT after normalization.

```cpp
Quatd q(1,2,3,4);
q.getAxis();

QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
q.normalize().getAxis(assumeUnit);//same as q.getAxis()

```

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

### printSetup()

Source: https://docs.opencv.org/5.0/extra_modules/classcv_1_1bioinspired_1_1TransientAreasSegmentationModule.html

Prints the setup parameters of the module.

```APIDOC
## printSetup()

### Description
Prints the setup parameters of the module.

### Method
printSetup

### Signature
void printSetup() const

### Parameters
None

### Returns
None
```

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

### Command-line parameters for create_board.cpp sample

Source: https://docs.opencv.org/5.0/tutorials/objdetect/aruco_board_detection/aruco_board_detection.html

Example command-line arguments for the create_board.cpp sample: output path, board dimensions, marker length, separation, and dictionary.

```text
"_output_path_/aboard.png" -w=5 -h=7 -l=100 -s=10 -d=10
```

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

### Quatd getAngle() example

Source: https://docs.opencv.org/5.0/main_modules/classcv_1_1Quat.html

Shows two ways to get the rotation angle: directly and with QUAT_ASSUME_UNIT after normalization.

```cpp
Quatd q(1,2,3,4);
q.getAngle();

QuatAssumeType assumeUnit = QUAT_ASSUME_UNIT;
q.normalize().getAngle(assumeUnit);//same as q.getAngle().

```

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

### startWindowThread Python example

Source: https://docs.opencv.org/5.0/main_modules/highgui.html

Python binding for cv.startWindowThread. Starts a thread to handle window events; returns a retval.

```python
cv.startWindowThread() -> retval

```

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

### Run the example program

Source: https://docs.opencv.org/5.0/tutorials/introduction/windows_msys2_vscode/window_install_opencv.html

Runs the compiled executable. If everything is configured correctly, a window should appear displaying a blank image.

```bash
./app.exe

```

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

### ldd output with all dependencies satisfied

Source: https://docs.opencv.org/5.0/tutorials/introduction/crosscompilation/crosscompile_with_multiarch.html

Example ldd output where all required libraries for the freetype module are installed, including libharfbuzz.so.0.

```text
linux-vdso.so.1 (0xABCDEFG01234567)
libopencv_imgproc.so.408 => /usr/local/lib/libopencv_imgproc.so.408 (0xABCDEF001234567)
libfreetype.so.6 => /lib/aarch64-linux-gnu/libfreetype.so.6 (0xABCDEF001234567)
libharfbuzz.so.0 => /lib/aarch64-linux-gnu/libharfbuzz.so.0 (0xABCDEF001234567)
libopencv_core.so.408 => /usr/local/lib/libopencv_core.so.408 (0xABCDEF001234567)
:

```

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

### Command-line parameters for detect_board_charuco.cpp (second example)

Source: https://docs.opencv.org/5.0/tutorials/objdetect/charuco_detection/charuco_detection.html

Example parameters for the detect_board_charuco.cpp sample, including video and camera calibration file paths.

```text
-w=5 -h=7 -sl=0.04 -ml=0.02 -d=10
-v=/path_to_opencv/opencv/doc/tutorials/objdetect/charuco_detection/images/choriginal.jpg
-c=/path_to_opencv/opencv/samples/cpp/tutorial_code/objectDetection/tutorial_camera_charuco.yml

```

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

### C++ example main.cpp

Source: https://docs.opencv.org/5.0/tutorials/introduction/windows_msys2_vscode/window_install_opencv.html

A simple C++ program that prints the OpenCV version and displays a blank image window. Used to verify the installation.

```cpp
#include <opencv2/opencv.hpp>
#include <iostream>

int main()
{
    std::cout << "OpenCV Version: " << CV_VERSION << std::endl;

    cv::Mat img = cv::Mat::zeros(400, 400, CV_8UC3);

    cv::imshow("OpenCV Test", img);
    cv::waitKey(0);

    return 0;
}

```

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

### Command-line parameters for create_board_charuco.cpp

Source: https://docs.opencv.org/5.0/tutorials/objdetect/charuco_detection/charuco_detection.html

Example command-line arguments for the create_board_charuco.cpp sample: output path, board width (-w=5), height (-h=7), square length (-sl=100), marker length (-ml=60), and dictionary (-d=10).

```text
"_output_path_/chboard.png" -w=5 -h=7 -sl=100 -ml=60 -d=10

```

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

### Doxygen comment with @warning for cv::Mat

Source: https://docs.opencv.org/5.0/tutorials/introduction/cross_referencing/tutorial_cross_referencing.html

Example of a Doxygen comment block that warns about a function returning a cv::Mat. This is the starting point for cross-referencing.

```cpp
/**
 * @warning This functions returns a cv::Mat.
 */
```

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

### Set up Intel oneAPI environment

Source: https://docs.opencv.org/5.0/tutorials/introduction/oneapi_install/oneapi_install.html

Sources the oneAPI environment variables for default installation.

```bash
source /opt/intel/oneapi/setvars.sh
```

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

### findNonZero with cv::Mat output

Source: https://docs.opencv.org/5.0/main_modules/core_array.html

Example of using cv::findNonZero to get non-zero pixel locations into a cv::Mat. Access coordinates via locations.at<Point>(i).

```cpp
cv::Mat binaryImage; // input, binary image
cv::Mat locations;   // output, locations of non-zero pixels
cv::findNonZero(binaryImage, locations);

// access pixel coordinates
Point pnt = locations.at<Point>(i);

```

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

### Set and get sensor properties using VideoCapture::set and get

Source: https://docs.opencv.org/5.0/tutorials/app/intelperc.html

Use VideoCapture::set and VideoCapture::get to configure and read sensor properties. The example sets the depth generator profile index to 0 and prints the FPS. The depth generator flag is assumed by default if no generator flag is specified.

```cpp
VideoCapture capture(CAP_REALSENSE);
capture.set( CAP_INTELPERC_DEPTH_GENERATOR | CAP_PROP_INTELPERC_PROFILE_IDX, 0 );
cout << "FPS    " << capture.get( CAP_INTELPERC_DEPTH_GENERATOR+CAP_PROP_FPS ) << endl;

```

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

### Complete main() launching a viz window

Source: https://docs.opencv.org/5.0/tutorials_contrib/viz/launching_viz/launching_viz.html

Complete example that creates a 3D visualization window, runs event loops, accesses the same window by name, and demonstrates spinning for a fixed time. Ends when the user presses q, Q, e, or E.

```cpp
int main()
{
    help();
    /// Create a window
    viz::Viz3d myWindow("Viz Demo");

    /// Start event loop
    myWindow.spin();

    /// Event loop is over when pressed q, Q, e, E
    cout << "First event loop is over" << endl;

    /// Access window via its name
    viz::Viz3d sameWindow = viz::getWindowByName("Viz Demo");

    /// Start event loop
    sameWindow.spin();

    /// Event loop is over when pressed q, Q, e, E
    cout << "Second event loop is over" << endl;

    /// Event loop is over when pressed q, Q, e, E
    /// Start event loop once for 1 millisecond
    sameWindow.spinOnce(1, true);
    while(!sameWindow.wasStopped())
    {
        /// Interact with window

        /// Event loop for 1 millisecond
        sameWindow.spinOnce(1, true);
    }

    /// Once more event loop is stopped
    cout << "Last event loop is over" << endl;
    return 0;
}
```

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

### Example: using TickMeter with operator<<

Source: https://docs.opencv.org/5.0/main_modules/core_utils.html

Shows how to use the stream output operator for cv::TickMeter: start the timer, perform the work, stop it, and print the result with std::cout.

```cpp
TickMeter tm;
tm.start();
// do something ...
tm.stop();
std::cout << tm;
```

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

### setup(String)

Source: https://docs.opencv.org/5.0/extra_modules/classcv_1_1bioinspired_1_1TransientAreasSegmentationModule.html

Loads segmentation parameters from an XML file specified by filename.

```APIDOC
## setup(String)

### Description
Tries to open an XML segmentation parameters file to adjust the current segmentation instance setup. If the XML file does not exist, default setup is applied. Exceptions are thrown if the read XML file is not valid.

### Method
setup

### Signature
`void cv::bioinspired::TransientAreasSegmentationModule::setup(String segmentationParameterFile = "", const bool applyDefaultSetupOnFailure = true)`

### Python
```
cv.bioinspired.TransientAreasSegmentationModule.setup([, segmentationParameterFile[, applyDefaultSetupOnFailure]])
```

### Parameters
- **segmentationParameterFile** (String) - Optional. The parameters filename. Default is "".
- **applyDefaultSetupOnFailure** (bool) - Optional. Set to true if an error must be thrown on error. Default is true.

### Returns
None
```

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

### Install GTK, camera, and media support dependencies

Source: https://docs.opencv.org/5.0/py_tutorials/py_setup/py_setup_in_ubuntu/py_setup_in_ubuntu.html

Install libraries for GUI (GTK), camera (v4l), and media support (FFmpeg, GStreamer).

```bash
sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev
sudo apt-get install libgstreamer-plugins-base1.0-dev libgstreamer1.0-dev

```

```bash
sudo apt-get install libgtk2.0-dev

```

```bash
sudo apt-get install libgtk-3-dev

```

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

### findNonZero with std::vector<Point> output

Source: https://docs.opencv.org/5.0/main_modules/core_array.html

Example of using cv::findNonZero to get non-zero pixel locations into a std::vector<Point>. Access coordinates via locations[i].

```cpp
cv::Mat binaryImage; // input, binary image
vector<Point> locations;   // output, locations of non-zero pixels
cv::findNonZero(binaryImage, locations);

// access pixel coordinates
Point pnt = locations[i];

```

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

### OpenCV build script (installOCV.sh)

Source: https://docs.opencv.org/5.0/tutorials/introduction/windows_install/windows_install.html

Bash script that clones or updates OpenCV and opencv_contrib, then builds and installs them. Configured for Visual Studio 16 2019 by default, with commented alternatives for VS 2017 and VS 2019 with x64. Disables perf tests, tests, docs, CUDA, and examples. Installs to c:/lib/install/opencv.

```bash
#!/bin/bash -e
myRepo=$(pwd)
CMAKE_GENERATOR_OPTIONS=-G"Visual Studio 16 2019"
#CMAKE_GENERATOR_OPTIONS=-G"Visual Studio 15 2017 Win64"
#CMAKE_GENERATOR_OPTIONS=(-G"Visual Studio 16 2019" -A x64)  # CMake 3.14+ is required
if [  ! -d "$myRepo/opencv"  ]; then
    echo "cloning opencv"
    git clone https://github.com/opencv/opencv.git
else
    cd opencv
    git pull --rebase
    cd ..
fi
if [  ! -d "$myRepo/opencv_contrib"  ]; then
    echo "cloning opencv_contrib"
    git clone https://github.com/opencv/opencv_contrib.git
else
    cd opencv_contrib
    git pull --rebase
    cd ..
fi
RepoSource=opencv
mkdir -p build_opencv
pushd build_opencv
CMAKE_OPTIONS=(-DBUILD_PERF_TESTS:BOOL=OFF -DBUILD_TESTS:BOOL=OFF -DBUILD_DOCS:BOOL=OFF  -DWITH_CUDA:BOOL=OFF -DBUILD_EXAMPLES:BOOL=OFF -DINSTALL_CREATE_DISTRIB=ON)
set -x
cmake "${CMAKE_GENERATOR_OPTIONS[@]}" "${CMAKE_OPTIONS[@]}" -DOPENCV_EXTRA_MODULES_PATH="$myRepo"/opencv_contrib/modules -DCMAKE_INSTALL_PREFIX="$myRepo/install/$RepoSource" "$myRepo/$RepoSource"
echo "************************* $Source_DIR -->debug"
cmake --build .  --config debug
echo "************************* $Source_DIR -->release"
cmake --build .  --config release
cmake --build .  --target install --config release
cmake --build .  --target install --config debug
popd

```

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

### Retina::setup (file)

Source: https://docs.opencv.org/5.0/extra_modules/classcv_1_1bioinspired_1_1Retina.html

Configures the retina model from a configuration file.

```APIDOC
## Image Processing Method: setup

### Method
setup

### Signature
```cpp
void cv::bioinspired::Retina::setup(const std::string& retinaConfigFile)
```

### Description
Configures the retina model from a configuration file.

### Parameters
- **retinaConfigFile** (const std::string&) - Required - Path to the configuration file.

### Return Value
void
```

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

### Run the example with node

Source: https://docs.opencv.org/5.0/js_tutorials/js_setup/js_nodejs/js_nodejs.html

Executes the example script. Save the file as exampleNodeJimp.js and ensure lena.jpg exists in the current directory. This command generates output.png.

```bash
node exampleNodeJimp.js

```

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

### Minimal OpenCV.js Node.js example (example1.js)

Source: https://docs.opencv.org/5.0/js_tutorials/js_setup/js_nodejs/js_nodejs.html

Defines a global Module with onRuntimeInitialized to run code once OpenCV.js is ready, then loads opencv.js via require. Save as example1.js with opencv.js in the same folder and Node.js installed.

```javascript
// Define a global variable 'Module' with a method 'onRuntimeInitialized':
Module = {
  onRuntimeInitialized() {
    // this is our application:
    console.log(cv.getBuildInformation())
  }
}
// Load 'opencv.js' assigning the value to the global variable 'cv'
cv = require('./opencv.js')

```

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

### Command-line parameters for detect_board_charuco.cpp (first example)

Source: https://docs.opencv.org/5.0/tutorials/objdetect/charuco_detection/charuco_detection.html

Example parameters for the detect_board_charuco.cpp sample, using cv::CommandLineParser. Includes board dimensions, square and marker lengths, dictionary ID, and a video path.

```text
-w=5 -h=7 -sl=0.04 -ml=0.02 -d=10 -v=/path_to_opencv/opencv/doc/tutorials/objdetect/charuco_detection/images/choriginal.jpg

```

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

### Retrieve depth map using VideoCapture::operator>>

Source: https://docs.opencv.org/5.0/tutorials/app/kinect_openni.html

Shows how to get a depth map from a depth sensor using the VideoCapture::operator>>. The example uses CAP_OPENNI2 as the capture source and loops until a key is pressed.

```cpp
VideoCapture capture( CAP_OPENNI2 );
for(;;)
{
    Mat depthMap;
    capture >> depthMap;

    if( waitKey( 30 ) >= 0 )
        break;
}

```

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

### Build and run OpenCV sample

Source: https://docs.opencv.org/5.0/tutorials/introduction/crosscompilation/crosscompile_with_multiarch.html

Commands to build the sample with make and run the resulting executable.

```bash
make a.out
./a.out

```

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

### Radius matching example using BinaryDescriptorMatcher internal database

Source: https://docs.opencv.org/5.0/tutorials_contrib/line_descriptor/tutorial.html

This example shows how to use the internal database of the BinaryDescriptorMatcher class. It loads a set of images, computes line descriptors using BinaryDescriptor, and then performs a radius search. The code includes the necessary OpenCV headers and uses the CommandLineParser to get the image path. It requires the OpenCV features module (HAVE_OPENCV_FEATURES) and the line_descriptor module.

```cpp
/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
 //
 //  By downloading, copying, installing or using the software you agree to this license.
 //  If you do not agree to this license, do not download, install,
 //  copy or use the software.
 //
 //
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
 // Copyright (C) 2014, Biagio Montesano, all rights reserved.
 // Third party copyrights are property of their respective owners.
 //
 // Redistribution and use in source and binary forms, with or without modification,
 // are permitted provided that the following conditions are met:
 //
 //   * Redistribution's of source code must retain the above copyright notice,
 //     this list of conditions and the following disclaimer.
 //
 //   * Redistribution's in binary form must reproduce the above copyright notice,
 //     this list of conditions and the following disclaimer in the documentation
 //     and/or other materials provided with the distribution.
 //
 //   * The name of the copyright holders may not be used to endorse or promote products
 //     derived from this software without specific prior written permission.
 //
 // This software is provided by the copyright holders and contributors "as is" and
 // any express or implied warranties, including, but not limited to, the implied
 // warranties of merchantability and fitness for a particular purpose are disclaimed.
 // In no event shall the Intel Corporation or contributors be liable for any direct,
 // indirect, incidental, special, exemplary, or consequential damages
 // (including, but not limited to, procurement of substitute goods or services;
 // loss of use, data, or profits; or business interruption) however caused
 // and on any theory of liability, whether in contract, strict liability,
 // or tort (including negligence or otherwise) arising in any way out of
 // the use of this software, even if advised of the possibility of such damage.
 //
 //M*/

#include <iostream>
#include <opencv2/opencv_modules.hpp>

#ifdef HAVE_OPENCV_FEATURES

#include <opencv2/line_descriptor.hpp>
#include <opencv2/core/utility.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/features.hpp>
#include <opencv2/highgui.hpp>

#include <vector>

using namespace cv;
using namespace cv::line_descriptor;

static const std::string images[] =
{ "cameraman.jpg", "church.jpg", "church2.png", "einstein.jpg", "stuff.jpg" };

static const char* keys =
{ "{@image_path | | Image path }" };

static void help()
{
  std::cout << "\nThis example shows the functionalities of radius matching " << "Please, run this sample using a command in the form\n"
      << "./example_line_descriptor_radius_matching <path_to_input_images>/" << std::endl;
}

int main( int argc, char** argv )
{
  /* get parameters from comand line */
  CommandLineParser parser( argc, argv, keys );
  String pathToImages = parser.get < String > ( 0 );

  /* create structures for hosting KeyLines and descriptors */
  int num_elements = sizeof ( images ) / sizeof ( images[0] );
  std::vector < Mat > descriptorsMat;
  std::vector < std::vector<KeyLine> > linesMat;

  /*create a pointer to a BinaryDescriptor object */
  Ptr < BinaryDescriptor > bd = BinaryDescriptor::createBinaryDescriptor();

  /* compute lines and descriptors */
  for ( int i = 0; i < num_elements; i++ )
  {
    /* get path to image */
    std::stringstream image_path;
    image_path << pathToImages << images[i];
    std::cout << image_path.str().c_str() << std::endl;

    /* load image */
    Mat loadedImage = imread( image_path.str().c_str(), 1 );
    if( loadedImage.data == NULL )
    {
      std::cout << "Could not load images." << std::endl;
      help();
      exit( -1 );
    }

```

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

### Command-line parameters for calibration example

Source: https://docs.opencv.org/5.0/tutorials/objdetect/aruco_calibration/aruco_calibration.html

Shows the command-line arguments used to run the calibration sample, including the camera calibration file, board dimensions, square and marker lengths, dictionary ID, and input image path.

```text
"camera_calib.txt" -w=5 -h=7 -sl=0.04 -ml=0.02 -d=10
-v=path/img_%02d.jpg
```

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

### Process row with Mat::ptr()

Source: https://docs.opencv.org/5.0/main_modules/classcv_1_1Mat.html

Shows how to efficiently process a whole row of a 2D matrix by getting a pointer to the row with ptr<double>() and using the plain C operator []. The example computes the sum of positive elements.

```cpp
// compute sum of positive matrix elements
// (assuming that M is a double-precision matrix)
double sum=0;
for(int i = 0; i < M.rows; i++)
{
    const double* Mi = M.ptr<double>(i);
    for(int j = 0; j < M.cols; j++)
        sum += std::max(Mi[j], 0.);
}
```

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

### Construct Mat with Factory Functions

Source: https://docs.opencv.org/5.0/js_tutorials/js_core/js_basic_ops/js_basic_ops.html

Shows two factory functions: matFromArray to create a Mat from a JS array, and matFromImageData to create a Mat from canvas image data. The example includes getting image data from a canvas context.

```javascript
// 1. Use JS array to construct a mat.
// For example: let mat = cv.matFromArray(2, 2, cv.CV_8UC1, [1, 2, 3, 4]);
let mat = cv.matFromArray(rows, cols, type, array);
// 2. Use imgData to construct a mat
let ctx = canvas.getContext("2d");
let imgData = ctx.getImageData(0, 0, canvas.width, canvas.height);
let mat = cv.matFromImageData(imgData);
```

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

### Run the example with node exampleNodeCanvas.js

Source: https://docs.opencv.org/5.0/js_tutorials/js_setup/js_nodejs/js_nodejs.html

Executes the saved example script, which should generate output.jpg in the current directory.

```bash
node exampleNodeCanvas.js

```

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

### training() usage example

Source: https://docs.opencv.org/5.0/extra_modules/classcv_1_1face_1_1FacemarkTrain.html

Shows how to create a FacemarkLBF instance with parameters, set the model filename, and call training(). Note that training samples must be added before calling training().

```cpp
FacemarkLBF::Params params;
params.model_filename = "ibug68.model"; // filename to save the trained model
Ptr<Facemark> facemark = FacemarkLBF::create(params);

// add training samples (see Facemark::addTrainingSample)

facemark->training();
```

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

### Full example: load image, dilate, and save with OpenCV.js in Node.js

Source: https://docs.opencv.org/5.0/js_tutorials/js_setup/js_nodejs/js_nodejs.html

Complete script that installs a minimal DOM, loads OpenCV.js, reads an image with cv.imread(), applies dilation, and writes the result to output.jpg. Requires a sample image lena.jpg in the current directory.

```javascript
const { Canvas, createCanvas, Image, ImageData, loadImage } = require('canvas');
const { JSDOM } = require('jsdom');
const { writeFileSync, existsSync, mkdirSync } = require("fs");

// This is our program. This time we use JavaScript async / await and promises to handle asynchronicity.
(async () => {

  // before loading opencv.js we emulate a minimal HTML DOM. See the function declaration below.
  installDOM();

  await loadOpenCV();

  // using node-canvas, we an image file to an object compatible with HTML DOM Image and therefore with cv.imread()
  const image = await loadImage('./lena.jpg');

  const src = cv.imread(image);
  const dst = new cv.Mat();
  const M = cv.Mat.ones(5, 5, cv.CV_8U);
  const anchor = new cv.Point(-1, -1);
  cv.dilate(src, dst, M, anchor, 1, cv.BORDER_CONSTANT, cv.morphologyDefaultBorderValue());

  // we create an object compatible HTMLCanvasElement
  const canvas = createCanvas(300, 300);
  cv.imshow(canvas, dst);
  writeFileSync('output.jpg', canvas.toBuffer('image/jpeg'));
  src.delete();
  dst.delete();
})();

// Load opencv.js just like before but using Promise instead of callbacks:
function loadOpenCV() {
  return new Promise(resolve => {
    global.Module = {
      onRuntimeInitialized: resolve
    };
    global.cv = require('./opencv.js');
  });
}

// Using jsdom and node-canvas we define some global variables to emulate HTML DOM.
// Although a complete emulation can be archived, here we only define those globals used
// by cv.imread() and cv.imshow().
function installDOM() {
  const dom = new JSDOM();
  global.document = dom.window.document;

  // The rest enables DOM image and canvas and is provided by node-canvas
  global.Image = Image;
  global.HTMLCanvasElement = Canvas;
  global.ImageData = ImageData;
  global.HTMLImageElement = Image;
}

```

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

### cv::GCPUKernel::m_setupF

Source: https://docs.opencv.org/5.0/main_modules/classcv_1_1GCPUKernel.html

Member variable holding the setup function.

```APIDOC
## Member Data: cv::GCPUKernel::m_setupF

### Description
Member variable holding the setup function.

### Declaration
```cpp
SetupF cv::GCPUKernel::m_setupF = nullptr
```

### Type
SetupF

### Default Value
nullptr
```

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

### Compute homography from camera displacement (C++)

Source: https://docs.opencv.org/5.0/examples/samples_cpp_tutorial_code_features_homography_homography_from_camera_displacement_cpp.html

This is the main example program. It reads two images, finds chessboard corners, solves PnP to get camera poses, computes the relative camera displacement, and then computes the homography. It uses OpenCV functions such as findChessboardCorners, solvePnP, Rodrigues, and computeC2MC1.

```cpp
#include <iostream>
#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/geometry.hpp>
#include <opencv2/objdetect.hpp>
#include <opencv2/calib.hpp>

using namespace std;
using namespace cv;

namespace
{
enum Pattern { CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID };

void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners, Pattern patternType = CHESSBOARD)
{
    corners.resize(0);

    switch (patternType)
    {
    case CHESSBOARD:
    case CIRCLES_GRID:
        for( int i = 0; i < boardSize.height; i++ )
            for( int j = 0; j < boardSize.width; j++ )
                corners.push_back(Point3f(float(j*squareSize),
                                          float(i*squareSize), 0));
        break;

    case ASYMMETRIC_CIRCLES_GRID:
        for( int i = 0; i < boardSize.height; i++ )
            for( int j = 0; j < boardSize.width; j++ )
                corners.push_back(Point3f(float((2*j + i % 2)*squareSize),
                                          float(i*squareSize), 0));
        break;

    default:
        CV_Error(Error::StsBadArg, "Unknown pattern type\n");
    }
}

//! [compute-homography]
Mat computeHomography(const Mat &R_1to2, const Mat &tvec_1to2, const double d_inv, const Mat &normal)
{
    Mat homography = R_1to2 + d_inv * tvec_1to2*normal.t();
    return homography;
}
//! [compute-homography]

Mat computeHomography(const Mat &R1, const Mat &tvec1, const Mat &R2, const Mat &tvec2,
                      const double d_inv, const Mat &normal)
{
    Mat homography = R2 * R1.t() + d_inv * (-R2 * R1.t() * tvec1 + tvec2) * normal.t();
    return homography;
}

//! [compute-c2Mc1]
void computeC2MC1(const Mat &R1, const Mat &tvec1, const Mat &R2, const Mat &tvec2,
                  Mat &R_1to2, Mat &tvec_1to2)
{
    //c2Mc1 = c2Mo * oMc1 = c2Mo * c1Mo.inv()
    R_1to2 = R2 * R1.t();
    tvec_1to2 = R2 * (-R1.t()*tvec1) + tvec2;
}
//! [compute-c2Mc1]

void homographyFromCameraDisplacement(const string &img1Path, const string &img2Path, const Size &patternSize,
                                      const float squareSize, const string &intrinsicsPath)
{
    Mat img1 = imread( samples::findFile( img1Path ) );
    Mat img2 = imread( samples::findFile( img2Path ) );

    //! [compute-poses]
    vector<Point2f> corners1, corners2;
    bool found1 = findChessboardCorners(img1, patternSize, corners1);
    bool found2 = findChessboardCorners(img2, patternSize, corners2);

    if (!found1 || !found2)
    {
        cout << "Error, cannot find the chessboard corners in both images." << endl;
        return;
    }

    vector<Point3f> objectPoints;
    calcChessboardCorners(patternSize, squareSize, objectPoints);

    FileStorage fs( samples::findFile( intrinsicsPath ), FileStorage::READ);
    Mat cameraMatrix, distCoeffs;
    fs["camera_matrix"] >> cameraMatrix;
    fs["distortion_coefficients"] >> distCoeffs;

    Mat rvec1, tvec1;
    solvePnP(objectPoints, corners1, cameraMatrix, distCoeffs, rvec1, tvec1);
    Mat rvec2, tvec2;
    solvePnP(objectPoints, corners2, cameraMatrix, distCoeffs, rvec2, tvec2);
    //! [compute-poses]

    Mat img1_copy_pose = img1.clone(), img2_copy_pose = img2.clone();
    Mat img_draw_poses;
    drawFrameAxes(img1_copy_pose, cameraMatrix, distCoeffs, rvec1, tvec1, 2*squareSize);
    drawFrameAxes(img2_copy_pose, cameraMatrix, distCoeffs, rvec2, tvec2, 2*squareSize);
    hconcat(img1_copy_pose, img2_copy_pose, img_draw_poses);
    imshow("Chessboard poses", img_draw_poses);

    //! [compute-camera-displacement]
    Mat R1, R2;
    Rodrigues(rvec1, R1);
    Rodrigues(rvec2, R2);

    Mat R_1to2, t_1to2;
    computeC2MC1(R1, tvec1, R2, tvec2, R_1to2, t_1to2);
    Mat rvec_1to2;
    Rodrigues(R_1to2, rvec_1to2);
    //! [compute-camera-displacement]

    //! [compute-plane-normal-at-camera-pose-1]
    Mat normal = Mat_<double>({3,1}, {0, 0, 1});
    Mat normal1 = R1*normal;
    //! [compute-plane-normal-at-camera-pose-1]

    //! [compute-plane-distance-to-the-camera-frame-1]
    Mat origin(3, 1, CV_64F, Scalar(0));
    Mat origin1 = R1*origin + tvec1;
    double d_inv1 = 1.0 / normal1.dot(origin1);
    //! [compute-plane-distance-to-the-camera-frame-1]

    //! [compute-homography-from-camera-displacement]

```

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

### Run PnP detection with configurable options

Source: https://docs.opencv.org/5.0/tutorials/calib3d/real_time_pose/real_time_pose.html

Command-line example to run the detection program with custom ratio, keypoint count, and fast matcher settings. The ratio threshold, number of keypoints, and use of the robust matcher can be adjusted.

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

```

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

### Extract sub-matrix and locate ROI with locateROI()

Source: https://docs.opencv.org/5.0/main_modules/classcv_1_1Mat.html

Shows how to extract a sub-matrix using Range and then use locateROI() to get the size and offset of the sub-matrix within the original matrix. The example creates a 10x10 identity matrix, extracts columns 1-3, then rows 5-9, and prints the resulting size and offset.

```cpp
Mat A = Mat::eye(10, 10, CV_32S);
// extracts A columns, 1 (inclusive) to 3 (exclusive).
Mat B = A(Range::all(), Range(1, 3));
// extracts B rows, 5 (inclusive) to 9 (exclusive).
// that is, C \~ A(Range(5, 9), Range(1, 3))
Mat C = B(Range(5, 9), Range::all());
Size size; Point ofs;
C.locateROI(size, ofs);
// size will be (width=10,height=10) and the ofs will be (x=1, y=5)
```
Tokens:
Raw