UAVProduct/SiftGPU/SiftPyramid.h
////////////////////////////////////////////////////////////////////////////
// File: SiftPyramid.h
// Author: Changchang Wu
// Description : interface for the SiftPyramid class.
// SiftPyramid: data storage for SIFT
// |---PyramidGL: OpenGL based implementation
// | |--PyramidNaive: Unpacked version
// | |--PyramidPacked: packed version
// |--PyramidCU: CUDA-based implementation
//
// Copyright (c) 2007 University of North Carolina at Chapel Hill
// All Rights Reserved
//
// Permission to use, copy, modify and distribute this software and its
// documentation for educational, research and non-profit purposes, without
// fee, and without a written agreement is hereby granted, provided that the
// above copyright notice and the following paragraph appear in all copies.
//
// The University of North Carolina at Chapel Hill make no representations
// about the suitability of this software for any purpose. It is provided
// 'as is' without express or implied warranty.
//
// Please send BUG REPORTS to ccwu@cs.unc.edu
//
////////////////////////////////////////////////////////////////////////////
#ifndef _SIFT_PYRAMID_H
#define _SIFT_PYRAMID_H
class GLTexImage;
class GLTexInput;
class SiftParam;
class GlobalUtil;
/////////////////////////////////////////////////////////////////////////////
//class SiftPyramid
//description: virutal class of SIFT data pyramid
// provides functions for SiftPU to run steps of GPU SIFT
// class PyramidNaive is the first implementation
// class PyramidPacked is a better OpenGL implementation
// class PyramidCU is a CUDA based implementation
/////////////////////////////////////////////////////////////////////////////
#define NO_DUPLICATE_DOWNLOAD
class SiftPyramid : public GlobalUtil
{
public:
enum{
DATA_GAUSSIAN = 0,
DATA_DOG = 1,
DATA_KEYPOINT = 2,
DATA_GRAD = 3,
DATA_ROT = 4,
DATA_NUM = 5
};
enum{
SIFT_SKIP_FILTERING = 0x01,
SIFT_SKIP_DETECTION = 0x02,
SIFT_SKIP_ORIENTATION = 0x04,
SIFT_RECT_DESCRIPTION = 0x08
};
protected:
SiftParam& param;
int _hpLevelNum;
int* _levelFeatureNum;
int _featureNum;
float* _histo_buffer;
//keypoint list
int _existing_keypoints;
vector<int> _keypoint_index;
//display vbo
GLuint* _featureDisplayVBO;
GLuint* _featurePointVBO;
public:
//
float _timing[8];
//image size related
//first octave
int _octave_min;
//how many octaves
int _octave_num;
//pyramid storage
int _pyramid_octave_num;
int _pyramid_octave_first;
int _pyramid_width;
int _pyramid_height;
int _down_sample_factor;
int _allocated;
int _alignment;
int _siftgpu_failed;
public:
vector<float> _keypoint_buffer;
vector<float> _descriptor_buffer;
private:
inline void PrepareBuffer();
inline void LimitFeatureCount(int have_keylist = 0);
public:
//shared by all implementations
virtual void RunSIFT(GLTexInput*input);
virtual void SaveSIFT(const char * szFileName);
virtual void CopyFeatureVector(float*keys, float *descriptors);
virtual void SetKeypointList(int num, const float * keys, int run_on_current, int skip_orientation);
//implementation-dependent functions
virtual void GetFeatureDescriptors() = 0;
virtual void GenerateFeatureListTex() =0;
virtual void ReshapeFeatureListCPU() =0;
virtual void GenerateFeatureDisplayVBO() =0;
virtual void DownloadKeypoints() = 0;
virtual void GenerateFeatureListCPU()=0;
virtual void GenerateFeatureList()=0;
virtual GLTexImage* GetLevelTexture(int octave, int level)=0;
virtual GLTexImage* GetLevelTexture(int octave, int level, int dataName) = 0;
virtual void BuildPyramid(GLTexInput * input)=0;
virtual void ResizePyramid(int w, int h) = 0;
virtual void InitPyramid(int w, int h, int ds = 0)=0;
virtual void DetectKeypointsEX() = 0;
virtual void ComputeGradient() = 0;
virtual void GetFeatureOrientations() = 0;
virtual void GetSimplifiedOrientation() = 0;
////////////////////////////////
virtual void CleanUpAfterSIFT() {}
virtual int IsUsingRectDescription() {return 0; }
static int GetRequiredOctaveNum(int inputsz);
///inline functions, shared by all implementations
inline void SetFailStatus() {_siftgpu_failed = 1; }
inline int GetSucessStatus() {return _siftgpu_failed == 0; }
inline int GetFeatureNum(){return _featureNum;}
inline int GetHistLevelNum(){return _hpLevelNum;}
inline const GLuint * GetFeatureDipslayVBO(){return _featureDisplayVBO;}
inline const GLuint * GetPointDisplayVBO(){return _featurePointVBO;}
inline const int * GetLevelFeatureNum(){return _levelFeatureNum;}
inline void GetPyramidTiming(float * timing){ for(int i = 0; i < 8; i++) timing[i] = _timing[i]; }
inline void CleanupBeforeSIFT()
{
_siftgpu_failed = 0;
for(int i = 0; i < 8; ++i) _timing[i] = 0;
}
SiftPyramid(SiftParam&sp):param(sp)
{
_featureNum = 0;
_featureDisplayVBO = 0;
_featurePointVBO = 0;
_levelFeatureNum = NULL;
_histo_buffer = NULL;
_hpLevelNum = 0;
//image size
_octave_num = 0;
_octave_min = 0;
_alignment = 1;
_pyramid_octave_num = _pyramid_octave_first = 0;
_pyramid_width = _pyramid_height = 0;
_allocated = 0;
_down_sample_factor = 0;
/////
_existing_keypoints = 0;
}
virtual ~SiftPyramid() {};
#ifdef DEBUG_SIFTGPU
private:
void StopDEBUG();
void BeginDEBUG(const char* imagepath);
void WriteTextureForDEBUG(GLTexImage * tex, const char * namet, ...);
#endif
};
#define SIFTGPU_ENABLE_REVERSE_ORDER
#ifdef SIFTGPU_ENABLE_REVERSE_ORDER
#define FIRST_OCTAVE(R) (R? _octave_num - 1 : 0)
#define NOT_LAST_OCTAVE(i, R) (R? (i >= 0) : (i < _octave_num))
#define GOTO_NEXT_OCTAVE(i, R) (R? (--i) : (++i))
#define FIRST_LEVEL(R) (R? param._dog_level_num - 1 : 0)
#define GOTO_NEXT_LEVEL(j, R) (R? (--j) : (++j))
#define NOT_LAST_LEVEL(j, R) (R? (j >= 0) : (j < param._dog_level_num))
#define FOR_EACH_OCTAVE(i, R) for(int i = FIRST_OCTAVE(R); NOT_LAST_OCTAVE(i, R); GOTO_NEXT_OCTAVE(i, R))
#define FOR_EACH_LEVEL(j, R) for(int j = FIRST_LEVEL(R); NOT_LAST_LEVEL(j, R); GOTO_NEXT_LEVEL(j, R))
#else
#define FOR_EACH_OCTAVE(i, R) for(int i = 0; i < _octave_num; ++i)
#define FOR_EACH_LEVEL(j, R) for(int j = 0; j < param._dog_level_num; ++j)
#endif
#endif