OpenGL interoperability

Overview

This section describes OpenGL interoperability. More…

CUDA-accelerated Computer Vision

Background Segmentation

Core part

Data Structures

Initalization and Information

Device layer

Feature Detection and Description

Image Filtering

Image Processing

Color space processing

Feature Detection

Histogram Calculation

Hough Transform

Image Warping

Legacy support

NPPST Core

NPPST Image Processing

NPPST Signal Processing

Object Detection

Operations on Matrices

Arithm Operations on Matrices

Core Operations on Matrices

Matrix Reductions

Per-element Operations

Optical Flow

Stereo Correspondence

Video Encoding/Decoding

// namespaces

namespace cv::cuda;
namespace cv::ogl::ocl;

// enums

enum cv::ogl::RenderModes;

// classes

class cv::ogl::Arrays;
class cv::ogl::Buffer;
class cv::ogl::Texture2D;

// global functions

void
cv::cuda::setGlDevice(int device = 0);

void
cv::ogl::convertFromGLTexture2D(
    const Texture2D& texture,
    OutputArray dst
    );

void
cv::ogl::convertToGLTexture2D(
    InputArray src,
    Texture2D& texture
    );

UMat
cv::ogl::mapGLBuffer(
    const Buffer& buffer,
    int accessFlags = ACCESS_READ|ACCESS_WRITE
    );

void
cv::ogl::render(
    const Texture2D& tex,
    Rect_<double> wndRect = Rect_<double>(0.0, 0.0, 1.0, 1.0),
    Rect_<double> texRect = Rect_<double>(0.0, 0.0, 1.0, 1.0)
    );

void
cv::ogl::render(
    const Arrays& arr,
    int mode = POINTS,
    Scalar color = Scalar::all(255)
    );

void
cv::ogl::render(
    const Arrays& arr,
    InputArray indices,
    int mode = POINTS,
    Scalar color = Scalar::all(255)
    );

void
cv::ogl::unmapGLBuffer(UMat& u);

Context&
cv::ogl::ocl::initializeContextFromGL();

Detailed Documentation

This section describes OpenGL interoperability.

To enable OpenGL support, configure OpenCV using CMake with WITH_OPENGL=ON . Currently OpenGL is supported only with WIN32, GTK and Qt backends on Windows and Linux (MacOS and Android are not supported). For GTK backend gtkglext-1.0 library is required.

To use OpenGL functionality you should first create OpenGL context (window or frame buffer). You can do this with namedWindow function or with other OpenGL toolkit (GLUT, for example).

Global Functions

void
cv::cuda::setGlDevice(int device = 0)

Sets a CUDA device and initializes it for the current thread with OpenGL interoperability.

This function should be explicitly called after OpenGL context creation and before any CUDA calls.

Parameters:

device

System index of a CUDA device starting with 0.

void
cv::ogl::convertFromGLTexture2D(
    const Texture2D& texture,
    OutputArray dst
    )

Converts Texture2D object to OutputArray.

Parameters:

texture	source Texture2D object.
dst	destination OutputArray.

void
cv::ogl::convertToGLTexture2D(
    InputArray src,
    Texture2D& texture
    )

Converts InputArray to Texture2D object.

Parameters:

src	source InputArray.
texture	destination Texture2D object.

UMat
cv::ogl::mapGLBuffer(
    const Buffer& buffer,
    int accessFlags = ACCESS_READ|ACCESS_WRITE
    )

Maps Buffer object to process on CL side (convert to UMat).

Function creates CL buffer from GL one, and then constructs UMat that can be used to process buffer data with OpenCV functions. Note that in current implementation UMat constructed this way doesn’t own corresponding GL buffer object, so it is the user responsibility to close down CL/GL buffers relationships by explicitly calling unmapGLBuffer() function.

Parameters:

buffer	source Buffer object.
accessFlags	data access flags (ACCESS_READ|ACCESS_WRITE).

Returns:

Returns UMat object

void
cv::ogl::render(
    const Texture2D& tex,
    Rect_<double> wndRect = Rect_<double>(0.0, 0.0, 1.0, 1.0),
    Rect_<double> texRect = Rect_<double>(0.0, 0.0, 1.0, 1.0)
    )

Render OpenGL texture or primitives.

Parameters:

tex	Texture to draw.
wndRect	Region of window, where to draw a texture (normalized coordinates).
texRect	Region of texture to draw (normalized coordinates).

void
cv::ogl::render(
    const Arrays& arr,
    int mode = POINTS,
    Scalar color = Scalar::all(255)
    )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

arr	Array of privitives vertices.
mode	Render mode. One of cv::ogl::RenderModes
color	Color for all vertices. Will be used if arr doesn’t contain color array.

void
cv::ogl::render(
    const Arrays& arr,
    InputArray indices,
    int mode = POINTS,
    Scalar color = Scalar::all(255)
    )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Parameters:

arr	Array of privitives vertices.
indices	Array of vertices indices (host or device memory).
mode	Render mode. One of cv::ogl::RenderModes
color	Color for all vertices. Will be used if arr doesn’t contain color array.

void
cv::ogl::unmapGLBuffer(UMat& u)

Unmaps Buffer object (releases UMat, previously mapped from Buffer).

Function must be called explicitly by the user for each UMat previously constructed by the call to mapGLBuffer() function.

Parameters:

u	source UMat, created by mapGLBuffer().

Context&
cv::ogl::ocl::initializeContextFromGL()

Creates OpenCL context from GL.

Returns:

Returns reference to OpenCL Context