SIFT 算法原理详解
SIFT（尺度不变特征变换，Scale-Invariant Feature Transform）是一种经典的局部特征检测和描述算法，它能够在不同的尺度、旋转和光照变化下稳定地检测图像特征。SIFT 主要包括以下几个步骤：尺度空间极值检测、关键点定位、方向分配、特征描述符生成，每个步骤的具体实现细节如下：
1. 尺度空间极值检测（Scale-space extrema detection）
尺度空间是指图像在不同尺度下的变化。SIFT 通过对图像应用不同的高斯模糊滤波器生成一系列不同尺度的图像（即尺度空间），并通过比较相邻尺度上的图像像素，寻找潜在的关键点。
具体步骤：
-
生成高斯金字塔：使用高斯模糊函数对图像进行多次模糊处理，得到不同尺度的图像。
-
高斯核
G(x, y, σ)公式为：G(x,y,σ)=12πσ2exp(−x2+y22σ2) G(x, y, \sigma) = \frac{1}{2\pi\sigma^2} \exp\left(-\frac{x^2 + y^2}{2\sigma^2}\right) G(x,y,σ)=2πσ21exp(−2σ2x2+y2)
其中，
σ表示高斯模糊的标准差。
-
-
构建尺度空间：
通过对原始图像应用不同的高斯模糊核，得到多个不同模糊程度的图像，形成尺度空间。在每个尺度下，都通过计算图像的差分（DoG，Difference of Gaussian）来检测图像的极值点（即潜在的特征点）。DoG 图像是通过在连续的尺度下应用高斯差分来构建的：
DoG(x,y,σ)=G(x,y,kσ)−G(x,y,σ) DoG(x, y, \sigma) = G(x, y, k\sigma) - G(x, y, \sigma) DoG(x,y,σ)=G(x,y,kσ)−G(x,y,σ)
其中，
k是常数，表示不同尺度间的倍数。 -
寻找极值点：
在尺度空间中，关键点是局部最大值或最小值，即在其邻域内（包括上、下两个尺度和当前尺度的8个邻域）具有极大或极小的响应值的点。
2. 关键点定位（Keypoint Localization）
通过尺度空间极值检测后，需要精确定位特征点。为了排除不稳定的低对比度点和边缘响应，SIFT 采用了一个细化步骤，基于泰勒展开和Hessian矩阵对关键点进行精确定位。
具体步骤：
- 低对比度点剔除：如果某个关键点的对比度低于一定阈值，则认为该点不稳定，应该剔除。
- 边缘响应抑制：对于边缘上的点，其信息量较少，容易受到噪声影响，需要进行抑制。SIFT 通过计算 Hessian 矩阵的条件数来判断是否为边缘点，如果条件数大于某个阈值，认为该点为边缘点，剔除掉。
3. 方向分配（Orientation Assignment）
为了提高特征点的旋转不变性，SIFT 为每个关键点分配一个或多个主方向。这是通过计算关键点邻域内的梯度方向分布来实现的。
具体步骤：
-
计算关键点邻域的梯度信息：
通过计算关键点邻域内每个像素点的梯度幅度和方向，得到一个方向直方图。- 梯度幅度：
m = sqrt( (Ix)^2 + (Iy)^2 ) - 梯度方向：
θ = atan2(Iy, Ix)
- 梯度幅度：
-
生成方向直方图：
根据梯度方向信息生成一个方向直方图。直方图的每个柱表示某个特定方向的梯度总和。 -
主方向分配：
对直方图进行高斯加权，选取最大峰值所对应的方向作为主方向。若直方图中存在多个峰值，则为该点分配多个方向。
4. 特征描述符生成（Keypoint Descriptor）
SIFT 通过对关键点的邻域进行细致描述，生成特征描述符，这个描述符可以用来进行特征匹配。描述符是一个具有旋转、尺度不变性的向量，能够高效地进行匹配。
具体步骤：
-
邻域区域划分：
通过将关键点邻域区域分成若干个子区域（通常为 4x4 网格），然后计算每个子区域的梯度信息。 -
计算子区域的梯度：
对每个子区域内的像素计算梯度信息（幅度和方向），并对梯度进行量化。每个子区域的方向直方图具有 8 个方向，因此每个子区域可以表示为一个 8 维向量。 -
构建描述符：
最终将所有子区域的方向直方图拼接起来，得到一个 128 维的描述符（4x4 网格，每个网格 8 个方向）。 -
归一化描述符：
对描述符进行归一化，确保其具有较强的鲁棒性，并进行剪切（防止过大的值影响稳定性）。
SIFT 在OpenCV中C++ 代码实现
以下是使用 OpenCV 实现 SIFT 特征检测与描述符提取的 C++ 代码示例：
#include <opencv2/opencv.hpp>
#include <opencv2/xfeatures2d.hpp>
#include <vector>
int main() {
// 读取图像
cv::Mat img = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
if (img.empty()) {
std::cerr << "Image not loaded!" << std::endl;
return -1;
}
// 创建 SIFT 特征检测器
cv::Ptr<cv::SIFT> sift = cv::SIFT::create();
// 关键点和描述符
std::vector<cv::KeyPoint> keypoints;
cv::Mat descriptors;
// 检测 SIFT 特征点并计算描述符
sift->detectAndCompute(img, cv::noArray(), keypoints, descriptors);
// 在图像中绘制关键点
cv::Mat img_keypoints;
cv::drawKeypoints(img, keypoints, img_keypoints);
// 显示带有关键点的图像
cv::imshow("SIFT Keypoints", img_keypoints);
cv::waitKey(0);
return 0;
}
C++ 代码解释：
- 加载图像：使用
cv::imread()读取图像，图像必须是灰度图像（SIFT 更适合在灰度图上工作）。 - SIFT 创建器：通过
cv::SIFT::create()创建一个 SIFT 对象。 - 检测和计算关键点与描述符：使用
detectAndCompute()方法来检测关键点并计算它们的描述符。 - 绘制关键点：使用
cv::drawKeypoints()在图像上绘制检测到的关键点。 - 显示图像：通过
cv::imshow()显示带有关键点的图像。
简化版的 SIFT 算法C++实现，包含以下步骤：
- 高斯金字塔生成
- DoG (差分高斯) 图像生成
- 关键点检测
- 方向分配
- 描述符生成
1. 高斯金字塔生成
首先，我们需要生成一个高斯金字塔。高斯金字塔是将图像通过不同的标准差（σ）进行高斯模糊后得到的图像序列。
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
// 高斯函数
float gaussian(float x, float y, float sigma) {
return exp(-(x*x + y*y) / (2 * sigma * sigma)) / (2 * M_PI * sigma * sigma);
}
// 高斯模糊
void gaussianBlur(const std::vector<std::vector<float>>& input, std::vector<std::vector<float>>& output, int radius, float sigma) {
int width = input.size();
int height = input[0].size();
int kernelSize = 2 * radius + 1;
// 计算高斯核
std::vector<std::vector<float>> kernel(kernelSize, std::vector<float>(kernelSize));
float sum = 0;
for (int i = -radius; i <= radius; ++i) {
for (int j = -radius; j <= radius; ++j) {
kernel[i + radius][j + radius] = gaussian(i, j, sigma);
sum += kernel[i + radius][j + radius];
}
}
// 归一化高斯核
for (int i = 0; i < kernelSize; ++i) {
for (int j = 0; j < kernelSize; ++j) {
kernel[i][j] /= sum;
}
}
// 应用高斯核进行模糊
for (int i = radius; i < width - radius; ++i) {
for (int j = radius; j < height - radius; ++j) {
float value = 0;
for (int ki = -radius; ki <= radius; ++ki) {
for (int kj = -radius; kj <= radius; ++kj) {
value += input[i + ki][j + kj] * kernel[ki + radius][kj + radius];
}
}
output[i][j] = value;
}
}
}
2. 差分高斯 (DoG) 图像生成
差分高斯 (DoG) 是通过减去相邻的两个高斯图像生成的，帮助检测图像的边缘和关键点。
void computeDoG(const std::vector<std::vector<float>>& image1, const std::vector<std::vector<float>>& image2, std::vector<std::vector<float>>& DoG) {
int width = image1.size();
int height = image1[0].size();
for (int i = 0; i < width; ++i) {
for (int j = 0; j < height; ++j) {
DoG[i][j] = image1[i][j] - image2[i][j];
}
}
}
3. 关键点检测
关键点检测步骤使用 DoG 图像的极值来寻找可能的关键点。我们需要检查每个像素在其邻域内的极值。
struct KeyPoint {
int x, y, octave, scale;
};
bool isExtrema(const std::vector<std::vector<float>>& DoG, int x, int y, int width, int height) {
float value = DoG[x][y];
bool isMax = true;
bool isMin = true;
for (int dx = -1; dx <= 1; ++dx) {
for (int dy = -1; dy <= 1; ++dy) {
if (x + dx >= 0 && x + dx < width && y + dy >= 0 && y + dy < height) {
if (DoG[x + dx][y + dy] > value) isMin = false;
if (DoG[x + dx][y + dy] < value) isMax = false;
}
}
}
return isMax || isMin;
}
std::vector<KeyPoint> detectKeyPoints(const std::vector<std::vector<std::vector<float>>>& DoGs, int width, int height) {
std::vector<KeyPoint> keypoints;
for (int octave = 0; octave < DoGs.size(); ++octave) {
for (int scale = 1; scale < DoGs[octave].size() - 1; ++scale) {
for (int x = 1; x < width - 1; ++x) {
for (int y = 1; y < height - 1; ++y) {
if (isExtrema(DoGs[octave][scale], x, y, width, height)) {
keypoints.push_back(KeyPoint{x, y, octave, scale});
}
}
}
}
}
return keypoints;
}
4. 方向分配
每个关键点通过其邻域的梯度方向来分配一个或多个方向，使得描述符具有旋转不变性。
// 梯度计算
void computeGradients(const std::vector<std::vector<float>>& image, std::vector<std::vector<float>>& magnitude, std::vector<std::vector<float>>& direction) {
int width = image.size();
int height = image[0].size();
for (int x = 1; x < width - 1; ++x) {
for (int y = 1; y < height - 1; ++y) {
float dx = image[x + 1][y] - image[x - 1][y];
float dy = image[x][y + 1] - image[x][y - 1];
magnitude[x][y] = sqrt(dx * dx + dy * dy);
direction[x][y] = atan2(dy, dx);
}
}
}
// 计算关键点的方向
void computeKeyPointOrientation(const std::vector<std::vector<float>>& image, int x, int y, int radius, float& orientation) {
std::vector<std::vector<float>> magnitude(image.size(), std::vector<float>(image[0].size()));
std::vector<std::vector<float>> direction(image.size(), std::vector<float>(image[0].size()));
computeGradients(image, magnitude, direction);
float sum = 0;
for (int i = -radius; i <= radius; ++i) {
for (int j = -radius; j <= radius; ++j) {
int ix = x + i, iy = y + j;
if (ix >= 0 && ix < image.size() && iy >= 0 && iy < image[0].size()) {
sum += magnitude[ix][iy] * direction[ix][iy];
}
}
}
orientation = sum;
}
5. 描述符生成
描述符通过计算每个关键点的邻域内的梯度方向来生成，并将其存储在一个128维的向量中。
std::vector<float> computeDescriptor(const std::vector<std::vector<float>>& image, int x, int y, int radius) {
std::vector<float> descriptor(128, 0.0f);
std::vector<std::vector<float>> magnitude(image.size(), std::vector<float>(image[0].size()));
std::vector<std::vector<float>> direction(image.size(), std::vector<float>(image[0].size()));
computeGradients(image, magnitude, direction);
int histSize = 8;
for (int i = -radius; i <= radius; ++i) {
for (int j = -radius; j <= radius; ++j) {
int ix = x + i, iy = y + j;
if (ix >= 0 && ix < image.size() && iy >= 0 && iy < image[0].size()) {
int histIdx = (int)(direction[ix][iy] / (2 * M_PI) * histSize) % histSize;
descriptor[histIdx] += magnitude[ix][iy];
}
}
}
return descriptor;
}
6. 总结
这是一个不依赖 OpenCV 的 SIFT 算法的简化实现。完整的 SIFT 算法实现通常会涉及更多细节，特别是在关键点定位、方向分配和描述符的构建方面。在实际使用中，OpenCV 提供了高度优化的实现，具有更高的性能和稳定性。如果需要更多细节或完整的实现，可以逐步改进上述代码，增加更多的步骤，例如边缘检测、Hessian 矩阵计算等。
总结
SIFT 算法通过多尺度图像处理、极值检测、关键点定位、旋转不变性和描述符生成等步骤，在图像特征检测和匹配中取得了重要进展。虽然它是一个计算量较大的算法，但它的鲁棒性和效果非常好，尤其适用于物体识别、图像拼接等任务。OpenCV 提供了对 SIFT 算法的高效实现，使其在实际应用中得到了广泛的使用。
扫一扫
57万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
