IEEE Robotics & Automation Magazine - June 2020 - 155

An example of the benchmarking code for measuring the
execution time is as follows:
1
2
3
4
5
6
7

double ticks = (double)cv::getTickCount();
if (use_gpu) {
gpu_processing(frame, dst);
} else {
cpu_processing(frame, dst);
}
ticks = ((double)cv::getTickCount() - ticks)/cv::getTick
Frequency()*1000;

The OpenCV functions cv::getTickCount() and
cv::getTickFrequency are used to obtain the number
of ticks before and after the processing work, translated into
seconds. A boolean variable indicates whether to use the CPU
or GPU; the value of this variable can be toggled through a
keyboard click.
In a second example, ORB features are detected and
extracted from the image. Such features are very important in
robotics applications, such as, for visual SLAM [9]. The
source code for the CPU version is as follows:
1 cv::Mat src, dst;
2 cv::Mat src_gray, descriptors;
3 std::vector keypoints;
4
5
6
7
8

cv::Ptr detector = cv::ORB::create();
cv::cvtColor( src, src_gray, cv::COLOR_BGR2GRAY );
detector->detect( src_gray, keypoints );
detector->compute( src_gray, keypoints, descriptors ) ;
cv::drawKeypoints( src, keypoints, dst,
cv::Scalar::all(-1), cv::DrawMatchesFlags::DEFAULT );

First, we define the necessary variables for storing the
original and final images, the intermediate gray image, and
the structures for storing the keypoints and descriptors of the
ORB features (lines 1-4). Second, the feature detector is initialized with default parameters in line 4. Finally, the processing steps are performed in lines 5-7; the original color image
is converted into a gray image, the keypoints are detected,
and their descriptors are computed. In line 8, the keypoints
are drawn into the destination image for visualization.
The CUDA version of this example is straightforward:
1
2
3
4

cv::Mat src, dst;
cv::cuda::GpuMat gpu_src, gpu_dst;
cv::cuda::GpuMat src_gray, descriptors;
std::vector keypoints;

5 gpu_src.upload(src);
6 cv::Ptr detector = cv::cuda::ORB::create();
7 cv::cuda::cvtColor( gpu_src, src_gray, cv::COLOR_BGR2GRAY );
8 detector->detect( src_gray, keypoints ) ;
9 detector->compute( src_gray, keypoints, descriptors );
10 cv::drawKeypoints( src, keypoints, dst,
cv::Scalar::all(-1), cv::DrawMatchesFlags::DEFAULT );

As in the previous example, we need to define two GpuMat
variables for the original and destination images (line 2). The
intermediate image is also stored in GPU memory, along with
the descriptors (line 3), but the keypoints are stored in CPU
memory (line 4). After uploading the image in line 5, the feature detector is created, and the processing steps are executed.
One should note that the processing code is basically similar to the previous version; lines 4-7 of the CPU code and
lines 6-9 of the GPU code differ only in the use of the
namespace cv::cuda instead of cv for the class ORB
(line 4/6) and the functions ORB::create
and cvtColor (lines
The usefulness of CUDA in
4/6 and 5/7).
Finally, drawing the
robotics and vision has been
keypoints is done in exactly the same way (line
successfully demonstrated
10 of the GPU code is the
same as line 8 of the CPU
with significant speedups in
code). The output of the
ORB detector is shown
many applications.
in Figure 5.
For debugging purposes, the code examples include visualization, and the corresponding function
calls have been included in the benchmarking. Since the
visualization process uses the same function call in both the
CPU and GPU versions, it should not affect the difference
between them in terms of performance.
The results are shown in Table 3. In this case, the GPUs are
faster than the CPUs due to the increased computational
workload demanded by the ORB algorithm. For simplicity,
this example has not computed the matching of ORB

Figure 5. The output image of the ORB feature detector.

Table 3. The computation times (in milliseconds)
for the ORB feature extraction algorithm (lower,
in bold, is better).
Desktop PC

Laptop PC

Embedded PC

CPU 15.323 ± 0.788 19.281 ± 0.883 101.586 ± 4.112
GPU 10.777 ± 1.246 11.588 ± 0.397 66.697 ± 2.936

JUNE 2020

*

IEEE ROBOTICS & AUTOMATION MAGAZINE

*

155
IEEE Robotics & Automation Magazine - June 2020

Table of Contents for the Digital Edition of IEEE Robotics & Automation Magazine - June 2020
