sift源碼下載

⑴ 緊急求助：在運行SIFT源碼時，由於是matlab和vc混編的，設置了mex後還是顯示找不到c文件。

我也用這個，好像是如果要把c的代碼編譯成mexw32的可執行程序，就需要在c代碼中有_mexFunction這個函數。
在mexutil.c裡面是一系列的工具函數，這個文件裡面沒有mexFunction函數。其他的可編譯的文件，如imsmooth.c裡面就有這個函數。而其他好多文件的編譯都需要用到這個mexutil.c，所以沒辦法用。
我試了一下把mexutil.c文件裡面的東西拷到那些需要用到mexutil.c的文件裡面，並且改了一下，再mex它們，就成功了。但是整個程序運行起來還是有點問題，不知道是不是因為有改動的原因。

⑵ 求助SURF演算法的源代碼

如果說SIFT演算法中使用DOG對LOG進行了簡化，提高了搜索特徵點的速度，那麼SURF演算法則是對DoH的簡化與近似。
雖然SIFT演算法已經被認為是最有效的，也是最常用的特徵點提取的演算法，但如果不藉助於硬體的加速和專用圖像處理器的配合，SIFT演算法以現有的計算機仍然很難達到實時的程度。

⑶ 網上找到的SIFT特徵提取代碼，怎麼使用

這是源碼里針對找到圖像特徵點進行聚類的函數，運行到這里sift演算法已經結束了。可以試著吧調用kmeans演算法的部分注釋掉，只執行sift演算法然後打出來特徵點看一下效果。我也不明白在一張圖像上對特徵點聚類的意義何在。對多張圖像聚類還有意義。

⑷ 如何本地安裝SIFT

SIFT的實現有很多版本，具體方式都是那麼幾個，找個好用的不太容易，因為對於代碼不熟練者各種版本用起來都有點水土不服，需要調整調整才行。本人是在VS2010下使用的Rob Hess的源碼。

一、前提

安裝Opencv，詳見：VS2010+Opencv-2.4.0的配置攻略（該版本SIFT是基於Opencv的）。

下載SIFT源碼，見Rob Hess的主頁（別告訴我不懂英文不知道下載鏈接在哪，下那個Windows VC++的版本 sift-latest_win.zip）。

二、測試

1、解壓sift源碼，發現有如下文件：

5、C語法設定：分別打開imgfeatures.h和sift.h，讓所有函數包含在

#ifdef __cplusplusextern"C"{#endif

和

#ifdef __cplusplus }#endif

之間。例如：

View Code

... #ifdef __cplusplusextern"C"{#endif...externintsift_features( IplImage* img,structfeature**feat ); ...externint_sift_features( IplImage* img,structfeature** feat,intintvls,doublesigma,doublecontr_thr,intcurv_thr,intimg_dbl,intdescr_width,intdescr_hist_bins ); #ifdef __cplusplus }#endif#endif

PS：我只是用了_sift_features(...)等幾個函數，所以只加了兩個頭文件的C語法聲明，如果是用了其他的頭文件，均需要添加。

6、綜上，你應該可以直接使用sift相關函數了，參照siftfeat.c中的寫法，用用_sift_features(...)試試！
實際上如果只需要使用SIFT特徵提取的函數，前面幾步只需要復制imgfeatures.c imgfeatures.h sift.c sift.h utils.c utils.h這6個文件就夠了

⑸ 我也求一份opencv下提取圖片sift特徵的項目源碼，急用，謝謝您了

#include "stdafx.h"
#include <opencv2/opencv.hpp>
double
compareSURFDescriptors( const float* d1, const float* d2, double best, int length )
{
double total_cost = 0;
assert( length % 4 == 0 );
for( int i = 0; i < length; i += 4 )
{
double t0 = d1[i ] - d2[i ];
double t1 = d1[i+1] - d2[i+1];
double t2 = d1[i+2] - d2[i+2];
double t3 = d1[i+3] - d2[i+3];
total_cost += t0*t0 + t1*t1 + t2*t2 + t3*t3;
if( total_cost > best )
break;
}
return total_cost;
}

int
naiveNearestNeighbor( const float* vec, int laplacian,
const CvSeq* model_keypoints,
const CvSeq* model_descriptors )
{
int length = (int)(model_descriptors->elem_size/sizeof(float));
int i, neighbor = -1;
double d, dist1 = 1e6, dist2 = 1e6;
CvSeqReader reader, kreader;
cvStartReadSeq( model_keypoints, &kreader, 0 );
cvStartReadSeq( model_descriptors, &reader, 0 );

for( i = 0; i < model_descriptors->total; i++ )
{
const CvSURFPoint* kp = (const CvSURFPoint*)kreader.ptr;
const float* mvec = (const float*)reader.ptr;
CV_NEXT_SEQ_ELEM( kreader.seq->elem_size, kreader );
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
if( laplacian != kp->laplacian )
continue;
d = compareSURFDescriptors( vec, mvec, dist2, length );
if( d < dist1 )
{
dist2 = dist1;
dist1 = d;
neighbor = i;
}
else if ( d < dist2 )
dist2 = d;
}
if ( dist1 < 0.6*dist2 )
return neighbor;
return -1;
}

void
findPairs( const CvSeq* objectKeypoints, const CvSeq* objectDescriptors,
const CvSeq* imageKeypoints, const CvSeq* imageDescriptors, vector<int>& ptpairs )
{
int i;
CvSeqReader reader, kreader;
cvStartReadSeq( objectKeypoints, &kreader );
cvStartReadSeq( objectDescriptors, &reader );
ptpairs.clear();

for( i = 0; i < objectDescriptors->total; i++ )
{
const CvSURFPoint* kp = (const CvSURFPoint*)kreader.ptr;
const float* descriptor = (const float*)reader.ptr;
CV_NEXT_SEQ_ELEM( kreader.seq->elem_size, kreader );
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
int nearest_neighbor = naiveNearestNeighbor( descriptor, kp->laplacian, imageKeypoints, imageDescriptors );
if( nearest_neighbor >= 0 )
{
ptpairs.push_back(i);
ptpairs.push_back(nearest_neighbor);
}
}
}

void
flannFindPairs( const CvSeq*, const CvSeq* objectDescriptors,
const CvSeq*, const CvSeq* imageDescriptors, vector<int>& ptpairs )
{
int length = (int)(objectDescriptors->elem_size/sizeof(float));

cv::Mat m_object(objectDescriptors->total, length, CV_32F);
cv::Mat m_image(imageDescriptors->total, length, CV_32F);

// descriptors
CvSeqReader obj_reader;
float* obj_ptr = m_object.ptr<float>(0);
cvStartReadSeq( objectDescriptors, &obj_reader );
for(int i = 0; i < objectDescriptors->total; i++ )
{
const float* descriptor = (const float*)obj_reader.ptr;
CV_NEXT_SEQ_ELEM( obj_reader.seq->elem_size, obj_reader );
memcpy(obj_ptr, descriptor, length*sizeof(float));
obj_ptr += length;
}
CvSeqReader img_reader;
float* img_ptr = m_image.ptr<float>(0);
cvStartReadSeq( imageDescriptors, &img_reader );
for(int i = 0; i < imageDescriptors->total; i++ )
{
const float* descriptor = (const float*)img_reader.ptr;
CV_NEXT_SEQ_ELEM( img_reader.seq->elem_size, img_reader );
memcpy(img_ptr, descriptor, length*sizeof(float));
img_ptr += length;
}

// find nearest neighbors using FLANN
cv::Mat m_indices(objectDescriptors->total, 2, CV_32S);
cv::Mat m_dists(objectDescriptors->total, 2, CV_32F);
cv::flann::Index flann_index(m_image, cv::flann::KDTreeIndexParams(4)); // using 4 randomized kdtrees
flann_index.knnSearch(m_object, m_indices, m_dists, 2, cv::flann::SearchParams(64) ); // maximum number of leafs checked

int* indices_ptr = m_indices.ptr<int>(0);
float* dists_ptr = m_dists.ptr<float>(0);
for (int i=0;i<m_indices.rows;++i) {
if (dists_ptr[2*i]<0.6*dists_ptr[2*i+1]) {
ptpairs.push_back(i);
ptpairs.push_back(indices_ptr[2*i]);
}
}
}

/* a rough implementation for object location */
int
locatePlanarObject( const CvSeq* objectKeypoints, const CvSeq* objectDescriptors,
const CvSeq* imageKeypoints, const CvSeq* imageDescriptors,
const CvPoint src_corners[4], CvPoint dst_corners[4] )
{
double h[9];
CvMat _h = cvMat(3, 3, CV_64F, h);
vector<int> ptpairs;
vector<CvPoint2D32f> pt1, pt2;
CvMat _pt1, _pt2;
int i, n;

#ifdef USE_FLANN
flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#else
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#endif

n = (int)(ptpairs.size()/2);
if( n < 4 )
return 0;

pt1.resize(n);
pt2.resize(n);
for( i = 0; i < n; i++ )
{
pt1[i] = ((CvSURFPoint*)cvGetSeqElem(objectKeypoints,ptpairs[i*2]))->pt;
pt2[i] = ((CvSURFPoint*)cvGetSeqElem(imageKeypoints,ptpairs[i*2+1]))->pt;
}

_pt1 = cvMat(1, n, CV_32FC2, &pt1[0] );
_pt2 = cvMat(1, n, CV_32FC2, &pt2[0] );
if( !cvFindHomography( &_pt1, &_pt2, &_h, CV_RANSAC, 5 ))
return 0;

for( i = 0; i < 4; i++ )
{
double x = src_corners[i].x, y = src_corners[i].y;
double Z = 1./(h[6]*x + h[7]*y + h[8]);
double X = (h[0]*x + h[1]*y + h[2])*Z;
double Y = (h[3]*x + h[4]*y + h[5])*Z;
dst_corners[i] = cvPoint(cvRound(X), cvRound(Y));
}

return 1;
}

int main(int argc, char** argv)
{
const char* object_filename = argc == 3 ? argv[1] : "box.png";
const char* scene_filename = argc == 3 ? argv[2] : "box_in_scene.png";
IplImage* object = cvLoadImage( object_filename, CV_LOAD_IMAGE_GRAYSCALE );
IplImage* image = cvLoadImage( scene_filename, CV_LOAD_IMAGE_GRAYSCALE );
if( !object || !image )
{
fprintf( stderr, "Can not load %s and/or %s\n",
object_filename, scene_filename );
exit(-1);
}

CvMemStorage* storage = cvCreateMemStorage(0);
cvNamedWindow("Object", 1);
cvNamedWindow("Object Correspond", 1);

static CvScalar colors[] =
{
{{0,0,255}},
{{0,128,255}},
{{0,255,255}},
{{0,255,0}},
{{255,128,0}},
{{255,255,0}},
{{255,0,0}},
{{255,0,255}},
{{255,255,255}}
};

IplImage* object_color = cvCreateImage(cvGetSize(object), 8, 3);
cvCvtColor( object, object_color, CV_GRAY2BGR );

CvSeq* objectKeypoints = 0, *objectDescriptors = 0;
CvSeq* imageKeypoints = 0, *imageDescriptors = 0;
int i;
CvSURFParams params = cvSURFParams(500, 1);

double tt = (double)cvGetTickCount();
cvExtractSURF( object, 0, &objectKeypoints, &objectDescriptors, storage, params );
printf("Object Descriptors: %d\n", objectDescriptors->total);

cvExtractSURF( image, 0, &imageKeypoints, &imageDescriptors, storage, params );
printf("Image Descriptors: %d\n", imageDescriptors->total);
tt = (double)cvGetTickCount() - tt;

printf( "Extraction time = %gms\n", tt/(cvGetTickFrequency()*1000.));

CvPoint src_corners[4] = {{0,0}, {object->width,0}, {object->width, object->height}, {0, object->height}};
CvPoint dst_corners[4];
IplImage* correspond = cvCreateImage( cvSize(image->width, object->height+image->height), 8, 1 );
cvSetImageROI( correspond, cvRect( 0, 0, object->width, object->height ) );
cvCopy( object, correspond );
cvSetImageROI( correspond, cvRect( 0, object->height, correspond->width, correspond->height ) );
cvCopy( image, correspond );
cvResetImageROI( correspond );

#ifdef USE_FLANN
printf("Using approximate nearest neighbor search\n");
#endif

if( locatePlanarObject( objectKeypoints, objectDescriptors, imageKeypoints,
imageDescriptors, src_corners, dst_corners ))
{
for( i = 0; i < 4; i++ )
{
CvPoint r1 = dst_corners[i%4];
CvPoint r2 = dst_corners[(i+1)%4];
cvLine( correspond, cvPoint(r1.x, r1.y+object->height ),
cvPoint(r2.x, r2.y+object->height ), colors[8] );
}
}
vector<int> ptpairs;
#ifdef USE_FLANN
flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#else
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#endif
for( i = 0; i < (int)ptpairs.size(); i += 2 )
{
CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, ptpairs[i] );
CvSURFPoint* r2 = (CvSURFPoint*)cvGetSeqElem( imageKeypoints, ptpairs[i+1] );
cvLine( correspond, cvPointFrom32f(r1->pt),
cvPoint(cvRound(r2->pt.x), cvRound(r2->pt.y+object->height)), colors[8] );
}

cvShowImage( "Object Correspond", correspond );
for( i = 0; i < objectKeypoints->total; i++ )
{
CvSURFPoint* r = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, i );
CvPoint center;
int radius;
center.x = cvRound(r->pt.x);
center.y = cvRound(r->pt.y);
radius = cvRound(r->size*1.2/9.*2);
cvCircle( object_color, center, radius, colors[0], 1, 8, 0 );
}
cvShowImage( "Object", object_color );

cvWaitKey(0);

cvDestroyWindow("Object");
cvDestroyWindow("Object Correspond");

return 0;
}

⑹ 圖像配准技術是怎麼實現圖像的特徵匹配的

SIFT圖像處理代碼，必須和三個文件一起下載使用：基於SIFT特徵的圖像配准（Matlab源代碼）、基於SIFT特徵的圖像配准（模擬圖片）

使用SIFT特徵描述對於部分物體遮蔽的偵測率也相當高，甚至只需要3個以上的SIFT物體特徵就足以計算出位置與方位。在現今的電腦硬體速度下和小型的特徵資料庫條件下，辨識速度可接近即時運算。SIFT特徵的信息量大，適合在海量資料庫中快速准確匹配。

⑺ 求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);
}
這就是核心代碼了。 還有什麼不懂，請追問

⑻ 求在vs2010和opencv 2.2環境下 sift匹配圖像源碼，求大神。

#include<ctime>

#include<iostream>

#include"opencv2/core/core.hpp"

#include"opencv2/features2d/features2d.hpp"

#include"opencv2/highgui/highgui.hpp"

#include"opencv2/calib3d/calib3d.hpp"

usingnamespacecv;

usingnamespacestd;

voidreadme();

//主函數

intmain(intargc,char*argv[])

{

if(argc>3)

{

readme();

return-1;

}

//默認參數

if(argc<3)

{

argv[1]="box.png";

argv[2]="box_in_scene.png";

}

//載入圖像

Matimg_object=imread(argv[1],CV_LOAD_IMAGE_GRAYSCALE);

Matimg_scene=imread(argv[2],CV_LOAD_IMAGE_GRAYSCALE);

if(!img_object.data||!img_scene.data)

{

std::cout<<"--(!)Errorreadingimages"<<std::endl;

return-1;

}

doublebegin=clock();

//第一步：用SIFT運算元檢測關鍵點

SiftFeatureDetectordetector;//構造函數採用默認的

std::vector<KeyPoint>keypoints_object,keypoints_scene;//構造2個專門由點組成的點向量用來存儲特徵點

detector.detect(img_object,keypoints_object);//將img_object圖像中檢測到的特徵點存儲起來放在keypoints_object中

detector.detect(img_scene,keypoints_scene);//同理

//在圖像中畫出特徵點

Matimg_keypoints_object,img_keypoints_scene;

//先在內存中繪制

drawKeypoints(img_object,keypoints_object,img_keypoints_object,Scalar::all(-1),DrawMatchesFlags::DEFAULT);//在內存中畫出特徵點

drawKeypoints(img_scene,keypoints_scene,img_keypoints_scene,Scalar::all(-1),DrawMatchesFlags::DEFAULT);

//再顯示

imshow("sift_keypoints_object",img_keypoints_object);

imshow("sift_keypoints_scene",img_keypoints_scene);

//第二步：計算特徵向量

;//定義描述子對象

Matdescriptors_1,descriptors_2;//存放特徵向量的矩陣

//計算特徵向量

extractor.compute(img_object,keypoints_object,descriptors_1);

extractor.compute(img_scene,keypoints_scene,descriptors_2);

//第三步，用FLANN進行匹配特徵向量

FlannBasedMatchermatcher;//定義一個FlannBasedMatcher對象

std::vector<DMatch>matches;

matcher.match(descriptors_1,descriptors_2,matches);

doublemax_dist=0;

doublemin_dist=100;

//計算特徵點間的最大最小距離

for(inti=0;i<descriptors_1.rows;i++)

{

doubledist=matches[i].distance;

if(dist<min_dist)min_dist=dist;

if(dist>max_dist)max_dist=dist;

}

printf("--Maxdist:%f ",max_dist);

printf("--Mindist:%f ",min_dist);

//只保留好的匹配：特徵點距離小於3倍最小距離

std::vector<DMatch>good_matches;

for(inti=0;i<descriptors_1.rows;i++)

{

if(matches[i].distance<3*min_dist)

{

good_matches.push_back(matches[i]);

}

}

//在內存中繪制保留的好的匹配

Matimg_matches;

drawMatches(img_object,keypoints_object,img_scene,keypoints_scene,

good_matches,img_matches,Scalar::all(-1),Scalar::all(-1),

vector<char>(),DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);

//在場景中定位目標圖像

std::vector<Point2f>obj;

std::vector<Point2f>scene;

std::cout<<"good_matches.size():"<<good_matches.size()<<" ";

for(inti=0;i<good_matches.size();i++)

{

//從好的匹配中找到特徵點

obj.push_back(keypoints_object[good_matches[i].queryIdx].pt);

scene.push_back(keypoints_scene[good_matches[i].trainIdx].pt);

}

//基於匹配的關鍵點找出相應的變換

cv::MatH=cv::findHomography(cv::Mat(obj),cv::Mat(scene),CV_RANSAC);

//找到目標的角點

std::vector<Point2f>obj_corners(4);

obj_corners[0]=cvPoint(0,0);

obj_corners[1]=cvPoint(img_object.cols,0);

obj_corners[2]=cvPoint(img_object.cols,img_object.rows);

obj_corners[3]=cvPoint(0,img_object.rows);

std::vector<Point2f>scene_corners(4);

//映射點群，在場景中獲取目標的坐標

cv::perspectiveTransform(cv::Mat(obj_corners),cv::Mat(scene_corners),H);

//目標的角點之間連線（框出目標）

line(img_matches,scene_corners[0]+Point2f(img_object.cols,0),scene_corners[1]+Point2f(img_object.cols,0),Scalar(0,255,0),4);

line(img_matches,scene_corners[1]+Point2f(img_object.cols,0),scene_corners[2]+Point2f(img_object.cols,0),Scalar(0,255,0),4);

line(img_matches,scene_corners[2]+Point2f(img_object.cols,0),scene_corners[3]+Point2f(img_object.cols,0),Scalar(0,255,0),4);

line(img_matches,scene_corners[3]+Point2f(img_object.cols,0),scene_corners[0]+Point2f(img_object.cols,0),Scalar(0,255,0),4);

//顯示保留的好的匹配

imshow("GoodMatches&Objectdetection-SIFT",img_matches);

imwrite("GoodMatches&Objectdetection-SIFT.png",img_matches);

doubleend=clock();

cout<<" SURF-elapsedtimeis:"<<(end-begin)/CLOCKS_PER_SEC*1000<<"ms ";

waitKey(0);

return0;

}

/**

*@函數readme

*/

voidreadme()

{

std::cout<<"Usage:./cv_sift_demo<img1><img2>"<<std::endl;

}

box_in_scene.png

⑼ SIFT，BLP，GLOH源代碼

描述子維數影響

低維運算元：steerable filters ,complex filters, differential invariants

基於微分的運算元，導數的階數影響著運算元的維數，對於steerable filters 三階導數和四階導數都能保持運算元的獨立性，並且導數的階數對運算元匹配的准確度影響顯而易見，但是對complex filters 和differential invariants影響較小。並且steerable filters 計算到四階導數時效果比differential invariants 效果好。

高維運算元：GLOH，PCA-SIFT，cross correlation 運算元 維數過高與過低效果都不理想。對於GLOH運算元，128維匹配效果高於40維和272維，對於PCA-SIFT36維效果好於20維和100維，對於cross correlation則81維匹配效果好於36維和400維。

8.對不同圖像變換的適應性

1）仿射變換。 利用Hessian Affine 和Harris Affine 檢測特徵點，然後對不同的局部運算元測試。效果最好的是SIFT運算元。並且利用Hessian Affine 比Harris Affine的效果好，因為基於拉普拉斯的尺度選擇與Hessian 運算元相結合可以獲得更准確的結果。

2）尺度變換 大多運算元表現良好

3）旋轉變換 有三種誤差影響運算元的計算：區域誤差，位置誤差，方向估計誤差

4）圖像模糊 所有的運算元性能都有所降低，但是GLOH和PCA-SIFT運算元性能最好，基於邊緣檢測的運算元性能下降最為明顯

5）圖像壓縮 影響小於圖像模糊，但是比尺度變換和旋轉變換大

6）光照變化 對低維運算元影響高於高維運算元

總結：1）GLOH性能最好，其次是SIFT

2）低維運算元中性能最好的是gradient moments和steerable filters

3）cross correlation 最不穩定

4） Hessian-Laplace 和Hessian-Affine 主要檢測圓斑狀結構。

5）由於更高的准確性，Hessian 區域比Harris區域性能更好一些