ORB 特征检测器

概述

Oriented FAST and rBRIEF (ORB) 是一种特征检测和描述算法。它在输入图像金字塔中检测特征，并为每个特征生成描述符，返回每个特征的坐标及其相关的位串描述符。此示例应用程序执行以下操作：（1）读取输入图像；（2）从图像创建高斯金字塔；（3）在金字塔上运行 ORB；（4）将 ORB 特征绘制为关键点，并用颜色表示 ORB 描述符；（5）写入带有彩色关键点的输出图像。每个特征都作为圆形绘制在输入图像之上，圆形的颜色根据与特征关联的描述符从蓝色到红色映射。该映射使用每个描述符到第一个描述符的汉明距离，因此蓝色关键点是第一个描述符，而黄色到红色的阴影则表示逐渐增加的距离。

说明

命令行参数为

<backend> <input image>

其中

• backend：cpu 或 cuda；它定义了将执行处理的后端。
• input image：要用作源图像的输入图像文件名，它接受 png、jpeg 和其他格式。

这是一个示例

• C++

  ./vpi_sample_18_orb_feature_detector cuda ../assets/kodim08.png

• Python

  python3 main.py cuda ../assets/kodim08.png

这是使用 CUDA 后端和提供的示例图像之一。您可以尝试其他图像，但需遵守算法施加的约束。

结果

输入图像	输入图像和翻转图像之间匹配的特征

源代码

为方便起见，以下代码也安装在 samples 目录中。

语言 C++ Python

import sys
import vpi
import numpy as np
from PIL import Image, ImageOps
from argparse import ArgumentParser
import cv2


# Parse command line arguments
parser = ArgumentParser()
parser.add_argument('backend', choices=['cpu','cuda'],
 help='Backend to be used for processing')

parser.add_argument('s', metavar='filename',
 help='Image to be used as source')

args = parser.parse_args()

if args.backend == 'cpu'
 backend = vpi.Backend.CPU
elif args.backend == 'cuda'
 backend = vpi.Backend.CUDA
else
 sys.exit("Un-supported backend")

# Load input image into a vpi.Image
try
 srcData = np.asarray(ImageOps.grayscale(Image.open(args.s)))
except IOError
 sys.exit("Source file not found")
except
 sys.exit("Error with source file")

src = vpi.asimage(srcData)

# Using the chosen backend to build the input pyramid and run ORB
with backend
 pyr = src.gaussian_pyramid(3)
 corners, descriptors = pyr.orb(intensity_threshold=142, max_features_per_level=88, max_pyr_levels=3)

# Draw the keypoints in the output image

out = src.convert(vpi.Format.BGR8, backend=vpi.Backend.CUDA)

if corners.size > 0
 distances = []
 with descriptors.rlock_cpu() as descriptors_data
 first_desc = descriptors_data[0][0]
 for i in range(descriptors.size)
 curr_desc = descriptors_data[i][0]
 hamm_dist = sum([bin(c ^ f).count('1') for c, f in zip(curr_desc, first_desc)])
 distances.append(hamm_dist)

 max_dist = max(distances)

 cmap = cv2.applyColorMap(np.arange(0, 256, dtype=np.uint8), cv2.COLORMAP_JET)
 cmap_idx = lambda i: int(round((distances[i] / max_dist) * 255))

 with out.lock_cpu() as out_data, corners.rlock_cpu() as corners_data
 for i in range(corners.size)
 color = tuple([int(x) for x in cmap[cmap_idx(i), 0]])
 kpt = tuple(corners_data[i].astype(np.int16))
 x = kpt[0] * (2 ** kpt[2])
 y = kpt[1] * (2 ** kpt[2])
 cv2.circle(out_data, (x, y), 3, color, -1)

# Save the output image to disk
cv2.imwrite('orb_feature_python'+str(sys.version_info[0])+'_'+args.backend+'.png', out.cpu())

#include <opencv2/core.hpp>
#include <opencv2/features2d.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/imgproc.hpp>
#include <vpi/OpenCVInterop.hpp>

#include <vpi/Array.h>
#include <vpi/Image.h>
#include <vpi/Pyramid.h>
#include <vpi/Status.h>
#include <vpi/Stream.h>
#include <vpi/algo/ConvertImageFormat.h>
#include <vpi/algo/GaussianPyramid.h>
#include <vpi/algo/ImageFlip.h>
#include <vpi/algo/ORB.h>

#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <numeric>
#include <sstream>
#include <vector>

#define CHECK_STATUS(STMT) \
 do \
 { \
 VPIStatus status = (STMT); \
 if (status != VPI_SUCCESS) \
 { \
 char buffer[VPI_MAX_STATUS_MESSAGE_LENGTH]; \
 vpiGetLastStatusMessage(buffer, sizeof(buffer)); \
 std::ostringstream ss; \
 ss << vpiStatusGetName(status) << ": " << buffer; \
 throw std::runtime_error(ss.str()); \
 } \
 } while (0);

static cv::Mat DrawKeypoints(cv::Mat img, VPIPyramidalKeypointF32 *kpts, VPIBriefDescriptor *descs, int numKeypoints)
{
 cv::Mat out;
 img.convertTo(out, CV_8UC1);
 cvtColor(out, out, cv::COLOR_GRAY2BGR);

 if (numKeypoints == 0)
 {
 return out;
 }

 std::vector<int> distances(numKeypoints, 0);
 float maxDist = 0.f;

 for (int i = 0; i < numKeypoints; i++)
 {
 for (int j = 0; j < VPI_BRIEF_DESCRIPTOR_ARRAY_LENGTH; j++)
 {
 distances[i] += std::bitset<8 * sizeof(uint8_t)>(descs[i].data[j] ^ descs[0].data[j]).count();
 }
 if (distances[i] > maxDist)
 {
 maxDist = distances[i];
 }
 }

 uint8_t ids[256];
 std::iota(&ids[0], &ids[0] + 256, 0);
 cv::Mat idsMat(256, 1, CV_8UC1, ids);

 cv::Mat cmap;
 applyColorMap(idsMat, cmap, cv::COLORMAP_JET);

 for (int i = 0; i < numKeypoints; i++)
 {
 int cmapIdx = static_cast<int>(std::round((distances[i] / maxDist) * 255));

 float rescale = std::pow(2, kpts[i].octave);
 float x = kpts[i].x * rescale;
 float y = kpts[i].y * rescale;

 circle(out, cv::Point(x, y), 3, cmap.at<cv::Vec3b>(cmapIdx, 0), -1);
 }

 return out;
}

int main(int argc, char *argv[])
{
 // OpenCV image that will be wrapped by a VPIImage.
 // Define it here so that it's destroyed *after* wrapper is destroyed
 cv::Mat cvImage;

 // VPI objects that will be used
 VPIImage imgInput = NULL;
 VPIImage imgGrayScale = NULL;

 VPIPyramid pyrInput = NULL;
 VPIArray keypoints = NULL;
 VPIArray descriptors = NULL;
 VPIPayload orbPayload = NULL;
 VPIStream stream = NULL;

 int retval = 0;

 try
 {
 // =============================
 // Parse command line parameters

 if (argc != 3)
 {
 throw std::runtime_error(std::string("Usage: ") + argv[0] + " <cpu|cuda> <input image>");
 }

 std::string strBackend = argv[1];
 std::string strInputFileName = argv[2];

 // Now parse the backend
 VPIBackend backend;

 if (strBackend == "cpu")
 {
 backend = VPI_BACKEND_CPU;
 }
 else if (strBackend == "cuda")
 {
 backend = VPI_BACKEND_CUDA;
 }
 else
 {
 throw std::runtime_error("Backend '" + strBackend + "' not recognized, it must be either cpu or cuda.");
 }

 // Use the selected backend with CPU to be able to read data back from CUDA to CPU for example.
 const VPIBackend backendWithCPU = static_cast<VPIBackend>(backend | VPI_BACKEND_CPU);

 // =====================
 // Load the input image

 cvImage = cv::imread(strInputFileName);
 if (cvImage.empty())
 {
 throw std::runtime_error("Can't open first image: '" + strInputFileName + "'");
 }

 // =================================
 // Allocate all VPI resources needed

 // Create the stream where processing will happen
 CHECK_STATUS(vpiStreamCreate(0, &stream));

 // Define the algorithm parameters.
 VPIORBParams orbParams;
 CHECK_STATUS(vpiInitORBParams(&orbParams));

 orbParams.fastParams.intensityThreshold = 142;
 orbParams.maxFeaturesPerLevel = 88;
 orbParams.maxPyramidLevels = 3;

 // We now wrap the loaded image into a VPIImage object to be used by VPI.
 // VPI won't make a copy of it, so the original image must be in scope at all times.
 CHECK_STATUS(vpiImageCreateWrapperOpenCVMat(cvImage, 0, &imgInput));
 CHECK_STATUS(vpiImageCreate(cvImage.cols, cvImage.rows, VPI_IMAGE_FORMAT_U8, 0, &imgGrayScale));

 // For the output arrays capacity we can use the maximum number of features per level multiplied by the
 // maximum number of pyramid levels, this will be the de factor maximum for all levels of the input.
 int outCapacity = orbParams.maxFeaturesPerLevel * orbParams.maxPyramidLevels;

 // Create the output keypoint array.
 CHECK_STATUS(vpiArrayCreate(outCapacity, VPI_ARRAY_TYPE_PYRAMIDAL_KEYPOINT_F32, backendWithCPU, &keypoints));

 // Create the output descriptors array. To output corners only use NULL instead.
 CHECK_STATUS(vpiArrayCreate(outCapacity, VPI_ARRAY_TYPE_BRIEF_DESCRIPTOR, backendWithCPU, &descriptors));

 // For the internal buffers capacity we can use the maximum number of features per level multiplied by 20.
 // This will make FAST find a large number of corners so then ORB can select the top N corners in
 // accordance to Harris score of each corner, where N = maximum number of features per level.
 int bufCapacity = orbParams.maxFeaturesPerLevel * 20;

 // Create the payload for ORB Feature Detector algorithm
 CHECK_STATUS(vpiCreateORBFeatureDetector(backend, bufCapacity, &orbPayload));

 // ================
 // Processing stage

 // First convert input to grayscale
 CHECK_STATUS(vpiSubmitConvertImageFormat(stream, backend, imgInput, imgGrayScale, NULL));

 // Then, create the Gaussian Pyramid for the image and wait for the execution to finish
 CHECK_STATUS(vpiPyramidCreate(cvImage.cols, cvImage.rows, VPI_IMAGE_FORMAT_U8, orbParams.maxPyramidLevels, 0.5,
 backend, &pyrInput));
 CHECK_STATUS(vpiSubmitGaussianPyramidGenerator(stream, backend, imgGrayScale, pyrInput, VPI_BORDER_CLAMP));

 // Then get ORB features and wait for the execution to finish
 CHECK_STATUS(vpiSubmitORBFeatureDetector(stream, backend, orbPayload, pyrInput, keypoints, descriptors,
 &orbParams, VPI_BORDER_LIMITED));

 CHECK_STATUS(vpiStreamSync(stream));

 // =======================================
 // 输出处理并保存到磁盘

 // 锁定输出关键点和分数，以在 CPU 内存上检索其数据
 VPIArrayData outKeypointsData;
 VPIArrayData outDescriptorsData;
 VPIImageData imgData;
 CHECK_STATUS(vpiArrayLockData(keypoints, VPI_LOCK_READ, VPI_ARRAY_BUFFER_HOST_AOS, &outKeypointsData));
 CHECK_STATUS(vpiArrayLockData(descriptors, VPI_LOCK_READ, VPI_ARRAY_BUFFER_HOST_AOS, &outDescriptorsData));
 CHECK_STATUS(vpiImageLockData(imgGrayScale, VPI_LOCK_READ, VPI_IMAGE_BUFFER_HOST_PITCH_LINEAR, &imgData));

 VPIPyramidalKeypointF32 *outKeypoints = (VPIPyramidalKeypointF32 *)outKeypointsData.buffer.aos.data;
 VPIBriefDescriptor *outDescriptors = (VPIBriefDescriptor *)outDescriptorsData.buffer.aos.data;

 cv::Mat img;
 CHECK_STATUS(vpiImageDataExportOpenCVMat(imgData, &img));

 // 在输出图像中绘制关键点
 cv::Mat outImage = DrawKeypoints(img, outKeypoints, outDescriptors, *outKeypointsData.buffer.aos.sizePointer);

 // 将输出图像保存到磁盘
 imwrite("orb_feature_detector_" + strBackend + ".png", outImage);

 // 完成输出处理，不要忘记解锁它们。
 CHECK_STATUS(vpiImageUnlock(imgGrayScale));
 CHECK_STATUS(vpiArrayUnlock(keypoints));
 CHECK_STATUS(vpiArrayUnlock(descriptors));
 }
 catch (std::exception &e)
 {
 std::cerr << e.what() << std::endl;
 retval = 1;
 }

 // ========
 // 清理

 // 确保在销毁可能仍在使用的对象之前同步流。
 // 确保在销毁可能仍在使用的对象之前同步流。
 vpiStreamSync(stream);

 vpiImageDestroy(imgInput);
 vpiImageDestroy(imgGrayScale);
 vpiArrayDestroy(keypoints);
 vpiArrayDestroy(descriptors);
 vpiPayloadDestroy(orbPayload);
 vpiStreamDestroy(stream);

 return retval;
}