root / rgbdslam / external / siftgpu / src / SiftGPU / SiftPyramid.h @ 9240aaa3
History | View | Annotate | Download (6.19 KB)
1 | 9240aaa3 | Alex | ////////////////////////////////////////////////////////////////////////////
|
---|---|---|---|
2 | // File: SiftPyramid.h
|
||
3 | // Author: Changchang Wu
|
||
4 | // Description : interface for the SiftPyramid class.
|
||
5 | // SiftPyramid: data storage for SIFT
|
||
6 | // |---PyramidGL: OpenGL based implementation
|
||
7 | // | |--PyramidNaive: Unpacked version
|
||
8 | // | |--PyramidPacked: packed version
|
||
9 | // |--PyramidCU: CUDA-based implementation
|
||
10 | //
|
||
11 | // Copyright (c) 2007 University of North Carolina at Chapel Hill
|
||
12 | // All Rights Reserved
|
||
13 | //
|
||
14 | // Permission to use, copy, modify and distribute this software and its
|
||
15 | // documentation for educational, research and non-profit purposes, without
|
||
16 | // fee, and without a written agreement is hereby granted, provided that the
|
||
17 | // above copyright notice and the following paragraph appear in all copies.
|
||
18 | //
|
||
19 | // The University of North Carolina at Chapel Hill make no representations
|
||
20 | // about the suitability of this software for any purpose. It is provided
|
||
21 | // 'as is' without express or implied warranty.
|
||
22 | //
|
||
23 | // Please send BUG REPORTS to ccwu@cs.unc.edu
|
||
24 | //
|
||
25 | ////////////////////////////////////////////////////////////////////////////
|
||
26 | |||
27 | |||
28 | |||
29 | #ifndef _SIFT_PYRAMID_H
|
||
30 | #define _SIFT_PYRAMID_H
|
||
31 | |||
32 | |||
33 | class GLTexImage; |
||
34 | class GLTexInput; |
||
35 | class SiftParam; |
||
36 | class GlobalUtil; |
||
37 | |||
38 | /////////////////////////////////////////////////////////////////////////////
|
||
39 | //class SiftPyramid
|
||
40 | //description: virutal class of SIFT data pyramid
|
||
41 | // provides functions for SiftPU to run steps of GPU SIFT
|
||
42 | // class PyramidNaive is the first implementation
|
||
43 | // class PyramidPacked is a better OpenGL implementation
|
||
44 | // class PyramidCU is a CUDA based implementation
|
||
45 | /////////////////////////////////////////////////////////////////////////////
|
||
46 | |||
47 | #define NO_DUPLICATE_DOWNLOAD
|
||
48 | |||
49 | class SiftPyramid : public GlobalUtil |
||
50 | { |
||
51 | public:
|
||
52 | enum{
|
||
53 | DATA_GAUSSIAN = 0,
|
||
54 | DATA_DOG = 1,
|
||
55 | DATA_KEYPOINT = 2,
|
||
56 | DATA_GRAD = 3,
|
||
57 | DATA_ROT = 4,
|
||
58 | DATA_NUM = 5
|
||
59 | }; |
||
60 | enum{
|
||
61 | SIFT_SKIP_FILTERING = 0x01,
|
||
62 | SIFT_SKIP_DETECTION = 0x02,
|
||
63 | SIFT_SKIP_ORIENTATION = 0x04,
|
||
64 | SIFT_RECT_DESCRIPTION = 0x08
|
||
65 | }; |
||
66 | protected:
|
||
67 | SiftParam& param; |
||
68 | int _hpLevelNum;
|
||
69 | int* _levelFeatureNum;
|
||
70 | int _featureNum;
|
||
71 | float* _histo_buffer;
|
||
72 | //keypoint list
|
||
73 | int _existing_keypoints;
|
||
74 | vector<int> _keypoint_index;
|
||
75 | //display vbo
|
||
76 | GLuint* _featureDisplayVBO; |
||
77 | GLuint* _featurePointVBO; |
||
78 | public:
|
||
79 | //
|
||
80 | float _timing[8]; |
||
81 | //image size related
|
||
82 | //first octave
|
||
83 | int _octave_min;
|
||
84 | //how many octaves
|
||
85 | int _octave_num;
|
||
86 | //pyramid storage
|
||
87 | int _pyramid_octave_num;
|
||
88 | int _pyramid_octave_first;
|
||
89 | int _pyramid_width;
|
||
90 | int _pyramid_height;
|
||
91 | int _down_sample_factor;
|
||
92 | int _allocated;
|
||
93 | int _alignment;
|
||
94 | int _siftgpu_failed;
|
||
95 | public:
|
||
96 | vector<float> _keypoint_buffer;
|
||
97 | vector<float> _descriptor_buffer;
|
||
98 | private:
|
||
99 | inline void PrepareBuffer(); |
||
100 | inline void LimitFeatureCount(int have_keylist = 0); |
||
101 | public:
|
||
102 | //shared by all implementations
|
||
103 | virtual void RunSIFT(GLTexInput*input);
|
||
104 | virtual void SaveSIFT(const char * szFileName); |
||
105 | virtual void CopyFeatureVector(float*keys, float *descriptors); |
||
106 | virtual void SetKeypointList(int num, const float * keys, int run_on_current, int skip_orientation); |
||
107 | //implementation-dependent functions
|
||
108 | virtual void GetFeatureDescriptors() = 0; |
||
109 | virtual void GenerateFeatureListTex() =0; |
||
110 | virtual void ReshapeFeatureListCPU() =0; |
||
111 | virtual void GenerateFeatureDisplayVBO() =0; |
||
112 | virtual void DownloadKeypoints() = 0; |
||
113 | virtual void GenerateFeatureListCPU()=0; |
||
114 | virtual void GenerateFeatureList()=0; |
||
115 | virtual GLTexImage* GetLevelTexture(int octave, int level)=0; |
||
116 | virtual GLTexImage* GetLevelTexture(int octave, int level, int dataName) = 0; |
||
117 | virtual void BuildPyramid(GLTexInput * input)=0; |
||
118 | virtual void ResizePyramid(int w, int h) = 0; |
||
119 | virtual void InitPyramid(int w, int h, int ds = 0)=0; |
||
120 | virtual void DetectKeypointsEX() = 0; |
||
121 | virtual void ComputeGradient() = 0; |
||
122 | virtual void GetFeatureOrientations() = 0; |
||
123 | virtual void GetSimplifiedOrientation() = 0; |
||
124 | |||
125 | ////////////////////////////////
|
||
126 | virtual void CleanUpAfterSIFT() {}
|
||
127 | virtual int IsUsingRectDescription() {return 0; } |
||
128 | static int GetRequiredOctaveNum(int inputsz); |
||
129 | |||
130 | ///inline functions, shared by all implementations
|
||
131 | inline void SetFailStatus() {_siftgpu_failed = 1; } |
||
132 | inline int GetSucessStatus() {return _siftgpu_failed == 0; } |
||
133 | inline int GetFeatureNum(){return _featureNum;} |
||
134 | inline int GetHistLevelNum(){return _hpLevelNum;} |
||
135 | inline const GLuint * GetFeatureDipslayVBO(){return _featureDisplayVBO;} |
||
136 | inline const GLuint * GetPointDisplayVBO(){return _featurePointVBO;} |
||
137 | inline const int * GetLevelFeatureNum(){return _levelFeatureNum;} |
||
138 | inline void GetPyramidTiming(float * timing){ for(int i = 0; i < 8; i++) timing[i] = _timing[i]; } |
||
139 | inline void CleanupBeforeSIFT() |
||
140 | { |
||
141 | _siftgpu_failed = 0;
|
||
142 | for(int i = 0; i < 8; ++i) _timing[i] = 0; |
||
143 | } |
||
144 | SiftPyramid(SiftParam&sp):param(sp) |
||
145 | { |
||
146 | _featureNum = 0;
|
||
147 | _featureDisplayVBO = 0;
|
||
148 | _featurePointVBO = 0;
|
||
149 | _levelFeatureNum = NULL;
|
||
150 | _histo_buffer = NULL;
|
||
151 | _hpLevelNum = 0;
|
||
152 | |||
153 | //image size
|
||
154 | _octave_num = 0;
|
||
155 | _octave_min = 0;
|
||
156 | _alignment = 1;
|
||
157 | _pyramid_octave_num = _pyramid_octave_first = 0;
|
||
158 | _pyramid_width = _pyramid_height = 0;
|
||
159 | _allocated = 0;
|
||
160 | _down_sample_factor = 0;
|
||
161 | |||
162 | /////
|
||
163 | _existing_keypoints = 0;
|
||
164 | } |
||
165 | virtual ~SiftPyramid() {}; |
||
166 | |||
167 | #ifdef DEBUG_SIFTGPU
|
||
168 | private:
|
||
169 | void StopDEBUG();
|
||
170 | void BeginDEBUG(const char* imagepath); |
||
171 | void WriteTextureForDEBUG(GLTexImage * tex, const char * namet, ...); |
||
172 | #endif
|
||
173 | }; |
||
174 | |||
175 | #define SIFTGPU_ENABLE_REVERSE_ORDER
|
||
176 | #ifdef SIFTGPU_ENABLE_REVERSE_ORDER
|
||
177 | #define FIRST_OCTAVE(R) (R? _octave_num - 1 : 0) |
||
178 | #define NOT_LAST_OCTAVE(i, R) (R? (i >= 0) : (i < _octave_num)) |
||
179 | #define GOTO_NEXT_OCTAVE(i, R) (R? (--i) : (++i))
|
||
180 | #define FIRST_LEVEL(R) (R? param._dog_level_num - 1 : 0) |
||
181 | #define GOTO_NEXT_LEVEL(j, R) (R? (--j) : (++j))
|
||
182 | #define NOT_LAST_LEVEL(j, R) (R? (j >= 0) : (j < param._dog_level_num)) |
||
183 | #define FOR_EACH_OCTAVE(i, R) for(int i = FIRST_OCTAVE(R); NOT_LAST_OCTAVE(i, R); GOTO_NEXT_OCTAVE(i, R)) |
||
184 | #define FOR_EACH_LEVEL(j, R) for(int j = FIRST_LEVEL(R); NOT_LAST_LEVEL(j, R); GOTO_NEXT_LEVEL(j, R)) |
||
185 | #else
|
||
186 | #define FOR_EACH_OCTAVE(i, R) for(int i = 0; i < _octave_num; ++i) |
||
187 | #define FOR_EACH_LEVEL(j, R) for(int j = 0; j < param._dog_level_num; ++j) |
||
188 | #endif
|
||
189 | |||
190 | #endif |