sift算法流程图

1. 我想问下 用SIFT提取的特征点 也就是关键点是些什么点 这些点中有角点或者圆心么

第一个为题：SIFT算法里面把角点，边缘点看做了不稳定的点，是需要去除的。所以提取不到角点；
匹配问题：只要找到了两幅图片的角点坐标，那么对两幅图片进行拼接，对应点连线即可，这里面也就涉及到一个坐标变换的问题。

2. sift算法是什么

Sift算法是David Lowe于1999年提出的局部特征描述子，并于2004年进行了更深入的发展和完善。Sift特征匹配算法可以处理两幅图像之间发生平移、旋转、仿射变换情况下的匹配问题，具有很强的匹配能力。

这一算法的灵感也十分的直观，人眼观测两张图片是否匹配时会注意到其中的典型区域（特征点部分），如果我们能够实现这一特征点区域提取过程，再对所提取到的区域进行描述就可以实现特征匹配了。

sift算法的应用

SIFT算法目前在军事、工业和民用方面都得到了不同程度的应用，其应用已经渗透了很多领域，典型的应用如下：物体识别；机器人定位与导航；图像拼接；三维建模；手势识别；视频跟踪；笔记鉴定；指纹与人脸识别；犯罪现场特征提取。

3. 新手求教 用sift处理后的图片得到的特征矩阵大小为什么不相同

SIFT做出来的矩阵本来就是行数不同的，要用上BOW模型

4. 在图像处理方面什么是SIFT匹配

一、特征点（角点）匹配
图像匹配能够应用的场合非常多，如目标跟踪，检测，识别，图像拼接等，而角点匹配最核心的技术就要属角点匹配了，所谓角点匹配是指寻找两幅图像之间的特征像素点的对应关系，从而确定两幅图像的位置关系。
角点匹配可以分为以下四个步骤：
1、提取检测子：在两张待匹配的图像中寻找那些最容易识别的像素点（角点），比如纹理丰富的物体边缘点等。
2、提取描述子：对于检测出的角点，用一些数学上的特征对其进行描述，如梯度直方图，局部随机二值特征等。检测子和描述子的常用提取方法有：sift，harris，surf，fast，agast，brisk，freak，brisk，brief/orb等。
3、匹配：通过各个角点的描述子来判断它们在两张图像中的对应关系，常用方法如 flann等。
4、消噪：去除错误匹配的外点，保留正确的匹配点。常用方法有KDTREE，BBF，Ransac，GTM等。
二、SIFT匹配方法的提出
为了排除因为图像遮挡和背景混乱而产生的无匹配关系的关键点，SIFT的作者Lowe提出了比较最近邻距离与次近邻距离的SIFT匹配方式：取一幅图像中的一个SIFT关键点，并找出其与另一幅图像中欧式距离最近的前两个关键点，在这两个关键点中，如果最近的距离除以次近的距离得到的比率ratio少于某个阈值T，则接受这一对匹配点。因为对于错误匹配，由于特征空间的高维性，相似的距离可能有大量其他的错误匹配，从而它的ratio值比较高。显然降低这个比例阈值T，SIFT匹配点数目会减少，但更加稳定，反之亦然。
Lowe推荐ratio的阈值为0.8，但作者对大量任意存在尺度、旋转和亮度变化的两幅图片进行匹配，结果表明ratio取值在0. 4~0. 6 之间最佳，小于0. 4的很少有匹配点，大于0. 6的则存在大量错误匹配点，所以建议ratio的取值原则如下:
ratio=0. 4：对于准确度要求高的匹配；
ratio=0. 6：对于匹配点数目要求比较多的匹配；
ratio=0. 5：一般情况下。
三、常见的SIFT匹配代码
1、vlfeat中sift toolbox中的vl_ubcmatch.c使用的是普通的欧氏距离进行匹配（该SIFT代码贡献自Andrea
Vedaldi）。
2、Lowe的C++代码中使用的是欧氏距离，但是在matlab代码中为了加速计算，使用的是向量夹角来近似欧氏距离：先将128维SIFT特征向量归一化为单位向量（每个数除以平方和的平方根），然后点乘来得到向量夹角的余弦值，最后利用反余弦（acos函数）求取向量夹角。实验证明Lowe的办法正确率和耗时都很不错。
同样，也可以采用knnsearch函数求最近点和次近点：knnsearch采用euclidean距离时得到的结果与lowe采用的近似方法结果几乎一致，正好印证了模拟欧氏距离的效果。
3、Rob Hess的OpenSIFT采用了KDTREE来对匹配进行优化。
4、CSDN大神v_JULY_v实现了KDTREE+BBF对SIFT匹配的优化和消除错误匹配：从K近邻算法、距离度量谈到KD树、SIFT+BBF算法
- 结构之法 算法之道 - 博客频道 - CSDN.NET。
5、OpenCV中features2d实现的SIFT匹配有多种matcher：VectorDescriptorMatcher，BFMatcher（Brute-force descriptor matcher），FernDescriptorMatcher，OneWayDescriptorMatcher，FlannBasedMatcher 等等。目前只知道采用knnsearch，提供了多种距离度量方式，具体区别不懂。

5. 什么是sift特征

sift特征匹配算法总结主要步骤
1)、尺度空间的生成；

2)、检测尺度空间极值点；

3)、精确定位极值点；

4)、为每个关键点指定方向参数；
5)、关键点描述子的生成。

6. 排序算法的设计（c语言）根据程序画流程图及对每句程序加注释

#include "stdio.h"//标准io头文件
#include "stdlib.h"//库文件
#include "time.h"//时间系头文件
#define N0 100000 //定义常量
typedef int keytype; //类型命名
typedef struct node //定义结构体
{ keytype key; //只是类型命名成keytype，其实就是int的
}Etp;//结构体类型叫做Etp
Etp R[N0+1]; // R[1]..R[n] //定义数组
int n=50, count;//全局变量
void readData( Etp R[], int n)//读数据的函数
{ int i;
count=0;
srand( time( NULL ));//初始化时间种子
for( i=1; i<=n; i++) //对数组初始化
R[i].key=1000+
(int)((9999.0-1000)*rand()/RAND_MAX); // 0..RAND_MAX
}
void printData( Etp R[], int n )//打印显示数据的函数
{ int i;
for( i=1; i<=n; i++)
printf("%8d%s", //格式化显示数组的数据
R[i].key, i%5==0?"\n":"");
printf("\ncount=%d\n", count);
}
void bubberSort( Etp R[], int n )//冒泡排序的函数
{ int i,j;//（这个函数块就是冒泡排序的算法程序）
bool swap;
for( i=1; i<=n-1; i++)
{ swap=false;
for( j=1; j<=n-i; j++)
if( count++,R[j].key>R[j+1].key )
{ R[0]=R[j];
R[j]=R[j+1];
R[j+1]=R[0];
swap=true;

}
if( !swap ) break;
}

}
void bubberSort1( Etp R[], int n )//这个也是另一个冒泡排序的函数
{ int j;//跟上面不同的是这个算法用的是递归的方式，上面的是非递归的
for( j=1; j<=n-1; j++)
if( count++,R[j].key>R[j+1].key )
{ R[0]=R[j];
R[j]=R[j+1];//________;//就是两个变量交换值
R[j+1]=R[0];
}
if( n>1 ) bubberSort1( R, n-1); //___________;//递归调用
}
void selectSort( Etp R[], int n )//这个是选择排序
{ int i,j,k;//（这个函数块就是选择排序的算法程序）
for( i=1; i<=n-1; i++)
{
k=i;
for( j=i+1; j<=n; j++)
if( count++,R[j].key<R[k].key ) k=j;
if( k!=i )
{ R[0]=R[i];
R[i]=R[k];
R[k]=R[0];
}
}
}
void insertSort( Etp R[], int n )//这个是插入排序
{ int i,j;
for( i=2; i<=n; i++)
{
R[0]=R[i];
j=i-1;
while( count++,R[j].key>R[0].key ) R[j+1]=R[j--];
R[j+1]=R[0];
count++;
}
}
void sift( Etp R[], int i, int m)//堆排序中的步骤
{ int k=2*i;
R[0]=R[i];
while( k<=m )
{ if( count++, k+1<=m && R[k+1].key>R[k].key) k++;
if( count++,R[0].key<R[k].key ) R[i]=R[k];
else break;
i=k;
k=2*i;
}
R[i]=R[0];
}
void heapSort( Etp R[], int n )//这个是堆排序
{ int j;
for( j=n/2; j>=1; j--) sift( R, j, n);
for( j=n; j>=2; j--)
{ R[0]=R[1];
R[1]=R[j];
R[j]=R[0];
sift( R, 1, j-1 );
}
}
int main()//主函数的进入口
{
readData( R, n );//读取数据
bubberSort1( R, n );//调用递归冒泡排序
printData( R, n);//显示数据

readData( R, n );//读取数据
selectSort( R, n );//调用选择排序
printData( R, n);//显示数据

readData( R, n );//读取数据
insertSort( R, n );//调用插入排序
printData( R, n);//显示数据

readData( R, n );//读取数据
heapSort( R, n );//调用堆排序
printData( R, n);//显示数据
return 0;
}
//诶·~注释完我总算看出来了，难道你要我解释各个排序的过程？
//那你还不如直接或者看书，你要是不理解原理是不可能看懂过程的。
//注释也只是语句的解释，但是过程的含义是无法描述的

7. 求opencv实现sift算法的程序

哈哈，我有一个基于opencv实现的sift，我把代码贴出来，你自己看看吧~~~
void sift_detector_and_descriptors(IplImage* i_left,IplImage* i_right)
{
Mat mat_image_left=Mat(i_left,false);
Mat mat_image_right=Mat(i_right,false);
cv::SiftFeatureDetector *pDetector=new cv::SiftFeatureDetector;
pDetector->detect(mat_image_left,left_key_point);
pDetector->detect(mat_image_right,right_key_point);
Mat left_image_descriptors,right_image_descriptors;
cv::SiftDescriptorExtractor *descriptor_extractor=new cv::SiftDescriptorExtractor;
descriptor_extractor->compute(mat_image_left,left_key_point,left_image_descriptors);
descriptor_extractor->compute(mat_image_right,right_key_point,right_image_descriptors);
Mat result_l,result_r;
drawKeypoints(mat_image_left,left_key_point,result_l,Scalar::all(-1),0);
drawKeypoints(mat_image_right,right_key_point,result_r,Scalar::all(-1),0);
//imshow("result_of_left_detector_sift",result_l);
//imshow("result_of_right_detector_sift",result_r);
Mat result_of_sift_match;
BruteForceMatcher<L2<float>> matcher;
matcher.match(left_image_descriptors,right_image_descriptors,result_of_point_match);
drawMatches(mat_image_left,left_key_point,mat_image_right,right_key_point,result_of_sift_match,result_of_sift_match);
imshow("matches_of_sift",result_of_sift_match);
imwrite("matches_of_sift.jpg",result_of_sift_match);
}
void main()
{
IplImage *n_left_image=cvLoadImage("D:\\lena.jpg");
IplImage *n_right_image=cvLoadImage("D:\\lena_r.jpg");
sift_detector_and_descriptors(n_left_image,n_right_image);
cvWaitKey(0);
}
这就是核心代码了。 还有什么不懂，请追问

8. 刚学sift算法，有些概念不明白，sift的第一步是找尺度空间的极值点，什么是尺度空间的极值点

先建立DoG尺度空间，然后确定S的值，最后比较DoG尺度空间中每个像素点和它邻近的26个点，确保尺度空间和二维图像空间都检测得到极值点，这些像素点的集合就是候选的关键点了。