root / rgbdslam / external / siftgpu / src / SiftGPU / SiftGPU.h @ 9240aaa3
History | View | Annotate | Download (14.6 KB)
1 |
////////////////////////////////////////////////////////////////////////////
|
---|---|
2 |
// File: SiftGPU.h
|
3 |
// Author: Changchang Wu
|
4 |
// Description : interface for the SIFTGPU class.
|
5 |
// SiftGPU: The SiftGPU Tool.
|
6 |
// SiftGPUEX: SiftGPU + viewer
|
7 |
// SiftParam: Sift Parameters
|
8 |
// SiftMatchGPU: GPU SIFT Matcher;
|
9 |
//
|
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 |
#ifndef GPU_SIFT_H
|
29 |
#define GPU_SIFT_H
|
30 |
|
31 |
#if defined(_WIN32)
|
32 |
#ifdef SIFTGPU_DLL
|
33 |
#ifdef DLL_EXPORT
|
34 |
#define SIFTGPU_EXPORT __declspec(dllexport)
|
35 |
#else
|
36 |
#define SIFTGPU_EXPORT __declspec(dllimport)
|
37 |
#endif
|
38 |
#else
|
39 |
#define SIFTGPU_EXPORT
|
40 |
#endif
|
41 |
|
42 |
#define SIFTGPU_EXPORT_EXTERN SIFTGPU_EXPORT
|
43 |
|
44 |
#if _MSC_VER > 1000 |
45 |
#pragma once
|
46 |
#endif
|
47 |
#else
|
48 |
#define SIFTGPU_EXPORT
|
49 |
#define SIFTGPU_EXPORT_EXTERN extern "C" |
50 |
#endif
|
51 |
|
52 |
///////////////////////////////////////////////////////////////////
|
53 |
//clss SiftParam
|
54 |
//description: SIFT parameters
|
55 |
////////////////////////////////////////////////////////////////////
|
56 |
class GlobalUtil; |
57 |
class SiftParam |
58 |
{ |
59 |
public:
|
60 |
float* _sigma;
|
61 |
float _sigma_skip0; // |
62 |
float _sigma_skip1; // |
63 |
|
64 |
//sigma of the first level
|
65 |
float _sigma0;
|
66 |
float _sigman;
|
67 |
int _sigma_num;
|
68 |
|
69 |
//how many dog_level in an octave
|
70 |
int _dog_level_num;
|
71 |
int _level_num;
|
72 |
|
73 |
//starting level in an octave
|
74 |
int _level_min;
|
75 |
int _level_max;
|
76 |
int _level_ds;
|
77 |
//dog threshold
|
78 |
float _dog_threshold;
|
79 |
//edge elimination
|
80 |
float _edge_threshold;
|
81 |
void ParseSiftParam();
|
82 |
public:
|
83 |
float GetLevelSigma(int lev); |
84 |
float GetInitialSmoothSigma(int octave_min); |
85 |
SIFTGPU_EXPORT SiftParam(); |
86 |
}; |
87 |
|
88 |
class LiteWindow; |
89 |
class GLTexInput; |
90 |
class ShaderMan; |
91 |
class SiftPyramid; |
92 |
class ImageList; |
93 |
////////////////////////////////////////////////////////////////
|
94 |
//class SIftGPU
|
95 |
//description: Interface of SiftGPU lib
|
96 |
////////////////////////////////////////////////////////////////
|
97 |
class SiftGPU:public SiftParam |
98 |
{ |
99 |
public:
|
100 |
enum
|
101 |
{ |
102 |
SIFTGPU_NOT_SUPPORTED = 0,
|
103 |
SIFTGPU_PARTIAL_SUPPORTED = 1, // detction works, but not orientation/descriptor |
104 |
SIFTGPU_FULL_SUPPORTED = 2
|
105 |
}; |
106 |
typedef struct SiftKeypoint |
107 |
{ |
108 |
float x, y, s, o; //x, y, scale, orientation. |
109 |
}SiftKeypoint; |
110 |
protected:
|
111 |
//when more than one images are specified
|
112 |
//_current indicates the active one
|
113 |
int _current;
|
114 |
//_initialized indicates if the shaders and OpenGL/SIFT parameters are initialized
|
115 |
//they are initialized only once for one SiftGPU inistance
|
116 |
//that is, SIFT parameters will not be changed
|
117 |
int _initialized;
|
118 |
//_image_loaded indicates if the current images are loaded
|
119 |
int _image_loaded;
|
120 |
//the name of current input image
|
121 |
char* _imgpath;
|
122 |
//_outpath containes the name of the output file
|
123 |
char* _outpath;
|
124 |
//the list of image filenames
|
125 |
ImageList * _list; |
126 |
//the texture that holds loaded input image
|
127 |
GLTexInput * _texImage; |
128 |
//the SiftPyramid
|
129 |
SiftPyramid * _pyramid; |
130 |
//print out the command line options
|
131 |
static void PrintUsage(); |
132 |
//Initialize OpenGL and SIFT paremeters, and create the shaders accordingly
|
133 |
void InitSiftGPU();
|
134 |
//load the image list from a file
|
135 |
void LoadImageList(char *imlist); |
136 |
public:
|
137 |
//timing results for 10 steps
|
138 |
float _timing[10]; |
139 |
inline const char* GetCurrentImagePath() {return _imgpath; } |
140 |
public:
|
141 |
//set the image list for processing
|
142 |
SIFTGPU_EXPORT virtual void SetImageList(int nimage, const char** filelist); |
143 |
//get the number of SIFT features in current image
|
144 |
SIFTGPU_EXPORT virtual int GetFeatureNum();
|
145 |
//save the SIFT result as a ANSCII/BINARY file
|
146 |
SIFTGPU_EXPORT virtual void SaveSIFT(const char * szFileName); |
147 |
//Copy the SIFT result to two vectors
|
148 |
SIFTGPU_EXPORT virtual void GetFeatureVector(SiftKeypoint * keys, float * descriptors); |
149 |
//Set keypoint list before running sift to get descriptors
|
150 |
SIFTGPU_EXPORT virtual void SetKeypointList(int num, const SiftKeypoint * keys, int keys_have_orientation = 1); |
151 |
//Enable downloading results to CPU.
|
152 |
//create a new OpenGL context for processing
|
153 |
//call VerifyContextGL instead if you want to crate openGL context yourself, or your are
|
154 |
//mixing mixing siftgpu with other openGL code
|
155 |
SIFTGPU_EXPORT virtual int CreateContextGL();
|
156 |
//verify the current opengl context..
|
157 |
//(for example, you call wglmakecurrent yourself and verify the current context)
|
158 |
SIFTGPU_EXPORT virtual int VerifyContextGL();
|
159 |
//check if all siftgpu functions are supported
|
160 |
SIFTGPU_EXPORT virtual int IsFullSupported();
|
161 |
//set verbose mode
|
162 |
SIFTGPU_EXPORT virtual void SetVerbose(int verbose = 4); |
163 |
//set SiftGPU to brief display mode, which is faster
|
164 |
inline void SetVerboseBrief(){SetVerbose(2);}; |
165 |
//parse SiftGPU parameters
|
166 |
SIFTGPU_EXPORT virtual void ParseParam(int argc, char **argv); |
167 |
//run SIFT on a new image given filename
|
168 |
SIFTGPU_EXPORT virtual int RunSIFT(const char * imgpath); |
169 |
//run SIFT on an image in the image list given the file index
|
170 |
SIFTGPU_EXPORT virtual int RunSIFT(int index); |
171 |
//run SIFT on a new image given the pixel data and format/type;
|
172 |
//gl_format (e.g. GL_LUMINANCE, GL_RGB) is the format of the pixel data
|
173 |
//gl_type (e.g. GL_UNSIGNED_BYTE, GL_FLOAT) is the data type of the pixel data;
|
174 |
//Check glTexImage2D(...format, type,...) for the accepted values
|
175 |
//Using image data of GL_LUMINANCE + GL_UNSIGNED_BYTE can minimize transfer time
|
176 |
SIFTGPU_EXPORT virtual int RunSIFT(int width, int height, const void * data, |
177 |
unsigned int gl_format, unsigned int gl_type); |
178 |
//run SIFT on current image (specified by arguments), or processing the current image again
|
179 |
SIFTGPU_EXPORT virtual int RunSIFT();
|
180 |
//run SIFT with keypoints on current image again.
|
181 |
SIFTGPU_EXPORT virtual int RunSIFT(int num, const SiftKeypoint * keys, int keys_have_orientation = 1); |
182 |
//constructor, the parameter np is ignored..
|
183 |
SIFTGPU_EXPORT SiftGPU(int np = 1); |
184 |
//destructor
|
185 |
SIFTGPU_EXPORT virtual ~SiftGPU(); |
186 |
//set the active pyramid...dropped function
|
187 |
SIFTGPU_EXPORT virtual void SetActivePyramid(int index) {} |
188 |
//retrieve the number of images in the image list
|
189 |
SIFTGPU_EXPORT virtual int GetImageCount();
|
190 |
//set parameter GlobalUtil::_ForceTightPyramid
|
191 |
SIFTGPU_EXPORT virtual void SetTightPyramid(int tight = 1); |
192 |
//allocate pyramid for a given size of image
|
193 |
SIFTGPU_EXPORT virtual int AllocatePyramid(int width, int height); |
194 |
//none of the texture in processing can be larger
|
195 |
//automatic down-sample is used if necessary.
|
196 |
SIFTGPU_EXPORT virtual void SetMaxDimension(int sz); |
197 |
///
|
198 |
public:
|
199 |
//overload the new operator because delete operator is virtual
|
200 |
//and it is operating on the heap inside the dll (due to the
|
201 |
//compiler setting of /MT and /MTd). Without the overloaded operator
|
202 |
//deleting a SiftGPU object will cause a heap corruption in the
|
203 |
//static link case (but not for the runtime dll loading).
|
204 |
SIFTGPU_EXPORT void* operator new (size_t size);
|
205 |
}; |
206 |
|
207 |
|
208 |
|
209 |
////////////////////////////////////////////////////////////////
|
210 |
//class SIftGPUEX
|
211 |
//description: adds some visualization functions to the interface of SiftGPU
|
212 |
////////////////////////////////////////////////////////////////
|
213 |
|
214 |
class SiftGPUEX:public SiftGPU |
215 |
{ |
216 |
//view mode
|
217 |
int _view;
|
218 |
//sub view mode
|
219 |
int _sub_view;
|
220 |
//whether display a debug view
|
221 |
int _view_debug;
|
222 |
//colors for SIFT feature display
|
223 |
enum{COLOR_NUM = 36}; |
224 |
float _colors[COLOR_NUM*3]; |
225 |
//display functions
|
226 |
void DisplayInput(); //display gray level image of input image |
227 |
void DisplayDebug(); //display debug view |
228 |
void DisplayFeatureBox(int i); //display SIFT features |
229 |
void DisplayLevel(void (*UseDisplayShader)(), int i); //display one level image |
230 |
void DisplayOctave(void (*UseDisplayShader)(), int i); //display all images in one octave |
231 |
//display different content of Pyramid by specifying different data and display shader
|
232 |
//the first nskip1 levels and the last nskip2 levels are skiped in display
|
233 |
void DisplayPyramid( void (*UseDisplayShader)(), int dataName, int nskip1 = 0, int nskip2 = 0); |
234 |
//use HSVtoRGB to generate random colors
|
235 |
static void HSVtoRGB(float hsv[3],float rgb[3]); |
236 |
|
237 |
public:
|
238 |
SIFTGPU_EXPORT SiftGPUEX(); |
239 |
//change view mode
|
240 |
SIFTGPU_EXPORT void SetView(int view, int sub_view, char * title); |
241 |
//display current view
|
242 |
SIFTGPU_EXPORT void DisplaySIFT();
|
243 |
//toggle debug mode on/off
|
244 |
SIFTGPU_EXPORT void ToggleDisplayDebug();
|
245 |
//randomize the display colors
|
246 |
SIFTGPU_EXPORT void RandomizeColor();
|
247 |
//retrieve the size of current input image
|
248 |
SIFTGPU_EXPORT void GetImageDimension(int &w, int&h); |
249 |
//get the location of the window specified by user
|
250 |
SIFTGPU_EXPORT void GetInitWindowPotition(int& x, int& y); |
251 |
}; |
252 |
|
253 |
///matcher export
|
254 |
//This is a gpu-based sift match implementation.
|
255 |
class SiftMatchGPU |
256 |
{ |
257 |
public:
|
258 |
enum SIFTMATCH_LANGUAGE {
|
259 |
SIFTMATCH_SAME_AS_SIFTGPU = 0, //when siftgpu already initialized. |
260 |
SIFTMATCH_GLSL = 2,
|
261 |
SIFTMATCH_CUDA = 3,
|
262 |
SIFTMATCH_CUDA_DEVICE0 = 3 //to use device i, use SIFTMATCH_CUDA_DEVICE0 + i |
263 |
}; |
264 |
private:
|
265 |
int __max_sift;
|
266 |
int __language;
|
267 |
SiftMatchGPU * __matcher; |
268 |
virtual void InitSiftMatch(){}
|
269 |
protected:
|
270 |
//move the two functions here for derived class
|
271 |
SIFTGPU_EXPORT virtual int _CreateContextGL();
|
272 |
SIFTGPU_EXPORT virtual int _VerifyContextGL();
|
273 |
public:
|
274 |
//OpenGL Context creation/verification, initialization is done automatically inside
|
275 |
inline int CreateContextGL() {return _CreateContextGL();} |
276 |
inline int VerifyContextGL() {return _VerifyContextGL();} |
277 |
|
278 |
//Consructor, the argument specifies the maximum number of features to match
|
279 |
SIFTGPU_EXPORT SiftMatchGPU(int max_sift = 4096); |
280 |
|
281 |
//change gpu_language, check the enumerants in SIFTMATCH_LANGUAGE.
|
282 |
SIFTGPU_EXPORT virtual void SetLanguage(int gpu_language); |
283 |
|
284 |
//after calling SetLanguage, you can call SetDeviceParam to select GPU
|
285 |
//-winpos, -display, -cuda [device_id]
|
286 |
//This is only used when you call CreateContextGL..
|
287 |
//This function doesn't change the language.
|
288 |
SIFTGPU_EXPORT virtual void SetDeviceParam(int argc, char**argv); |
289 |
|
290 |
//change the maximum of features to match whenever you want
|
291 |
SIFTGPU_EXPORT virtual void SetMaxSift(int max_sift); |
292 |
//desctructor
|
293 |
SIFTGPU_EXPORT virtual ~SiftMatchGPU(); |
294 |
|
295 |
//Specifiy descriptors to match, index = [0/1] for two features sets respectively
|
296 |
//Option1, use float descriptors, and they be already normalized to 1.0
|
297 |
SIFTGPU_EXPORT virtual void SetDescriptors(int index, int num, const float* descriptors, int id = -1); |
298 |
//Option 2 unsigned char descriptors. They must be already normalized to 512
|
299 |
SIFTGPU_EXPORT virtual void SetDescriptors(int index, int num, const unsigned char * descriptors, int id = -1); |
300 |
|
301 |
//match two sets of features, the function RETURNS the number of matches.
|
302 |
//Given two normalized descriptor d1,d2, the distance here is acos(d1 *d2);
|
303 |
SIFTGPU_EXPORT virtual int GetSiftMatch(
|
304 |
int max_match, // the length of the match_buffer. |
305 |
int match_buffer[][2], //buffer to receive the matched feature indices |
306 |
float distmax = 0.7, //maximum distance of sift descriptor |
307 |
float ratiomax = 0.8, //maximum distance ratio |
308 |
int mutual_best_match = 1); //mutual best match or one way |
309 |
|
310 |
//two functions for guded matching, two constraints can be used
|
311 |
//one homography and one fundamental matrix, the use is as follows
|
312 |
//1. for each image, first call SetDescriptor then call SetFeatureLocation
|
313 |
//2. Call GetGuidedSiftMatch
|
314 |
//input feature location is a vector of [float x, float y, float skip[gap]]
|
315 |
SIFTGPU_EXPORT virtual void SetFeautreLocation(int index, const float* locations, int gap = 0); |
316 |
inline void SetFeatureLocation(int index, const SiftGPU::SiftKeypoint * keys) |
317 |
{ |
318 |
SetFeautreLocation(index, (const float*) keys, 2); |
319 |
} |
320 |
|
321 |
//use a guiding Homography H and a guiding Fundamental Matrix F to compute feature matches
|
322 |
//the function returns the number of matches.
|
323 |
SIFTGPU_EXPORT virtual int GetGuidedSiftMatch(
|
324 |
int max_match, int match_buffer[][2], //buffer to recieve |
325 |
float H[3][3], //homography matrix, (Set NULL to skip) |
326 |
float F[3][3], //fundamental matrix, (Set NULL to skip) |
327 |
float distmax = 0.7, //maximum distance of sift descriptor |
328 |
float ratiomax = 0.8, //maximum distance ratio |
329 |
float hdistmax = 32, //threshold for |H * x1 - x2|_1 |
330 |
float fdistmax = 16, //threshold for sampson error of x2'FX1 |
331 |
int mutual_best_match = 1); //mutual best or one way |
332 |
|
333 |
public:
|
334 |
//overload the new operator, the same reason as SiftGPU above
|
335 |
SIFTGPU_EXPORT void* operator new (size_t size);
|
336 |
}; |
337 |
|
338 |
typedef SiftGPU::SiftKeypoint SiftKeypoint;
|
339 |
|
340 |
//Two exported global functions used to create SiftGPU and SiftMatchGPU
|
341 |
SIFTGPU_EXPORT_EXTERN SiftGPU * CreateNewSiftGPU(int np =1); |
342 |
SIFTGPU_EXPORT_EXTERN SiftMatchGPU* CreateNewSiftMatchGPU(int max_sift = 4096); |
343 |
|
344 |
|
345 |
////////////////////////////////////////////////////////////////////////////
|
346 |
class ComboSiftGPU: public SiftGPU, public SiftMatchGPU |
347 |
{ |
348 |
public:
|
349 |
///////////////////////////////////////////////
|
350 |
SIFTGPU_EXPORT void* operator new (size_t size);
|
351 |
}; |
352 |
SIFTGPU_EXPORT_EXTERN ComboSiftGPU* CreateComboSiftGPU(); |
353 |
|
354 |
/////////////////////////////////////////////////////////////////////////////////////////////
|
355 |
//Multi-process mode and remote mode
|
356 |
SIFTGPU_EXPORT_EXTERN ComboSiftGPU* CreateRemoteSiftGPU(int port = 7777, char* remote_server = NULL); |
357 |
//Run SiftGPU computation on a remote computer/process/thread
|
358 |
//if( remote_server == NULL)
|
359 |
// a local server is created in a different process and connected
|
360 |
// multiple-GPU can be used by creating multiple instances
|
361 |
// GPU selection done through SiftGPU::ParseParam function
|
362 |
//otherwise,
|
363 |
// Assumes the existenc of a remote server and connects to it
|
364 |
// GPU selection skipped if already done on the server-end
|
365 |
// RUN server: server_siftgpu -server port [siftgpu_param]
|
366 |
//example:
|
367 |
// ComboSiftGPU * combo = CreateRemoteSiftGPU(7777, "my.gpuserver.com");
|
368 |
// SiftGPU* siftgpu = combo, SiftMatchGPU * matcher = combo;
|
369 |
// siftgpu->ParseParam... siftgpu->CreateContextGL..
|
370 |
// matcher->SetLanguage...matcher->VerifyContextGL...
|
371 |
// // GPU-selection is done throught siftgpu->ParseParam,
|
372 |
// // it doesn't really initialize SiftGPU untill you call CreateContextGL/VerifyContextGL
|
373 |
// delete combo;
|
374 |
|
375 |
////////////////////////////////////////////////////////////////////////
|
376 |
//two internally used function.
|
377 |
SIFTGPU_EXPORT int CreateLiteWindow(LiteWindow* window);
|
378 |
SIFTGPU_EXPORT void RunServerLoop(int port, int argc, char** argv); |
379 |
#endif
|