SIFT:第一步使用OpenCV构建DOG金字塔

main函数

#include<opencv2/opencv.hpp>  

#include"PC_SIFT.h"

using namespace std;
using namespace cv;

int main(int argc,char*argv[])
{
	struct feature *feat;
	int n;
	Mat img1=cv::imread("E://corner.jpg",-1);
	if(!img1.data)
		{cout<<"Error!No such file!"<<endl;
			return -1;
	     }

	cv::namedWindow("test1",CV_WINDOW_AUTOSIZE);
	imshow("test1",img1);
	
	n=pc_sift_features(img1, &feat);

    cv::waitKey(0);
	
	return 0;

}

CPP文件

#include<opencv2/opencv.hpp> 
#include<math.h>

#include "PC_SIFT.h"

using namespace std;
using namespace cv;

Size Wsize(5,5);  // the size of gaussain smooth kernel

/*************************Static Function Feclaration**************************/ 
static int _sift_features( Mat, struct feature**, int ,double , double , int ,int , int );
static Mat create_init_img( Mat, double );
static void build_gauss_pyr( Mat,vector<Mat>&, int,int, double );
static Mat downsample( Mat);
static void build_dog_pyr(vector<Mat>&dog_pyr,vector<Mat>&gauss_pyr, int octvs, int intvls );



/************************Main function pc_sift_features************************/
/*we skipped the first ocatve */
int pc_sift_features(Mat img,struct feature ** feat)
{
 return _sift_features( img, feat, SIFT_INTVLS, SIFT_SIGMA, SIFT_CONTR_THR,
							SIFT_CURV_THR, SIFT_DESCR_WIDTH,
							SIFT_DESCR_HIST_BINS );		
							}

int _sift_features( Mat img, struct feature** feat, int intvls,
				   double sigma, double contr_thr, int curv_thr,
				   int descr_width, int descr_hist_bins )
{
	Mat init_img;
	vector<Mat> gauss_pyr,dog_pyr;

	int n=0;
	int octvs;
	/*create the init img via original gaussian smooth and converting to type 32 float*/
	init_img=create_init_img( img, sigma );

	/* build scale space pyramid;  */
	octvs=(int)log( static_cast<double>MIN( init_img.rows, init_img.cols ) ) / log(2.0) - 2;
	build_gauss_pyr( init_img,gauss_pyr, octvs, intvls, sigma );
	build_dog_pyr(dog_pyr,gauss_pyr,octvs,intvls);

	/*find scale extrama candidate keypoints and discard the bad points */ 

	/*display*/
	Mat display;
	string winName="1";
	char cnt='1';
	for(int i=0;i<=12;i++)
	{
	winName+=cnt;
	dog_pyr[i].convertTo(display,CV_8UC1);
	imshow(winName,display);
	}


	/*release the img and pyramid*/	
	return n;
}

static Mat create_init_img( Mat img, double sigma )
{
	Mat gray;
	double sig_diff;
	
	img.convertTo(gray,CV_32FC1);
	
	sig_diff = sqrt( sigma * sigma - SIFT_INIT_SIGMA * SIFT_INIT_SIGMA );

	cv::GaussianBlur(gray,gray,Wsize,sig_diff);
	
	return gray;
}

static void build_gauss_pyr( Mat base, vector<Mat> &gauss_pyr,int octvs,
									int intvls, double sigma )
{
	

	double* sig = (double*)calloc( intvls + 3, sizeof(double));
	gauss_pyr.resize(octvs*(intvls+3));

	double sig_total, sig_prev, k;
	int i, o;

	/*
		precompute Gaussian sigmas using the following formula:

		\sigma_{total}^2 = \sigma_{i}^2 + \sigma_{i-1}^2
	*/
	sig[0] = sigma;
	k = pow( 2.0, 1.0 / intvls );
	for( i = 1; i < intvls + 3; i++ )
	{
		sig_prev = pow( k, i - 1 ) * sigma;
		sig_total = sig_prev * k;
		sig[i] = sqrt( sig_total * sig_total - sig_prev * sig_prev );
	}

	/*****build gauss pyramid  *************/

	for( o = 0; o < octvs; o++ )
		for( i = 0; i < intvls + 3; i++ )
		{
			
			if( o == 0  &&  i == 0 )
				gauss_pyr[o*(intvls+3)+i]=base.clone();
			/* base of new octvave is halved image from end of previous octave */
			else if( i == 0 )				
				gauss_pyr[o*(intvls+3)+i]=downsample(gauss_pyr[(o-1)*(intvls+3)+intvls]);
			/* blur the current octave's last image to create the next one */
			else				
				cv::GaussianBlur(gauss_pyr[o*(intvls+3)+i-1],gauss_pyr[o*(intvls+3)+i],Wsize,sig[i]);
			
		}

	free( sig );
}

static Mat downsample( Mat img )
{   
	Mat smaller;
	smaller.create(img.rows/2,img.cols/2,CV_32FC1);
	cv::resize(img,smaller,cv::Size(img.rows/2,img.cols/2));
	return smaller;
}

static void build_dog_pyr(vector<Mat>&dog_pyr,vector<Mat>&gauss_pyr, int octvs, int intvls )
{
	dog_pyr.resize(octvs*(intvls+2));
	for(int o=0;o<octvs;o++)
		for(int i=0;i<intvls+2;i++)
		{
			Mat& src1=gauss_pyr[o*(intvls+3)+i+1];
			Mat& src2=gauss_pyr[o*(intvls+3)+i];
			Mat& dst=dog_pyr[o*(intvls+2)+i];
			cv::subtract(src1,src2,dst);				
		}
}

h文件

//#ifndef PC_SIFT_H
//#define PC_SIFT_H

#include<opencv2\opencv.hpp>

/** max feature descriptor length */
#define FEATURE_MAX_D 128

/**
Structure to represent an affine invariant image feature. 
*/
struct feature
{
	double x;                      /**< x coord */
	double y;                      /**< y coord */
	/*********/
	int octv;                      //  Octave
	int intvl;                     // inteval
	/*********/
	double scl;                    /**< scale of a Lowe-style feature */
	double ori;                    /**< orientation of a Lowe-style feature */
	int d;                         /**< descriptor length */
	double descr[FEATURE_MAX_D];   /**< descriptor */
	int category;                  /**< all-purpose feature category */
	struct feature* fwd_match;     /**< matching feature from forward image */

	CvPoint2D64f img_pt;           /**< location in image */
	CvPoint2D64f mdl_pt;           /**< location in model */
	void* feature_data;            /**< user-definable data */

};

/******************************* Defs and macros *****************************/


/** default number of sampled intervals per octave */
#define SIFT_INTVLS 3

/** default sigma for initial gaussian smoothing */
#define SIFT_SIGMA 1.6
/** default threshold on keypoint contrast |D(x)| */
#define SIFT_CONTR_THR 0.04

/** default threshold on keypoint ratio of principle curvatures */
#define SIFT_CURV_THR 10

/** double image size before pyramid construction? */
#define SIFT_IMG_DBL 0    //no, for sar img ,we abandon the first ovtave 

/** default width of descriptor histogram array */
#define SIFT_DESCR_WIDTH 4

/** default number of bins per histogram in descriptor array */
#define SIFT_DESCR_HIST_BINS 8

/* assumed gaussian blur for input image */
#define SIFT_INIT_SIGMA 0.5

/* width of border in which to ignore keypoints */
#define SIFT_IMG_BORDER 5

/***********                   Function Proto types              ********/


//int pc_sift_features(Mat img,struct feature ** feat);
extern "C" {  
extern int pc_sift_features(cv::Mat img,struct feature ** feat);
} 

//#endif

gaussian pyramid

DOG Pyramid