void Sift::extract(Image &image, std::vector<Feature> *list) {
float *fdata = new float[image.cv->width * image.cv->height];
BOOST_VERIFY(fdata);
{
float *d = fdata;
unsigned char *l = (unsigned char *)image.cv->imageData;
for (int h = 0; h < image.cv->height; ++h) {
for (int w = 0; w < image.cv->width; ++w) {
*d = float(l[w]);
d++;
}
l += image.cv->widthStep;
}
}
VlSiftFilt *filt = vl_sift_new (image.cv->width, image.cv->height, O, S, omin) ;
BOOST_VERIFY(filt);
if (edge_thresh >= 0) vl_sift_set_edge_thresh (filt, edge_thresh) ;
if (peak_thresh >= 0) vl_sift_set_peak_thresh (filt, peak_thresh) ;
if (magnif >= 0) vl_sift_set_magnif (filt, magnif) ;
magnif = vl_sift_get_magnif(filt);
list->clear();
int err = vl_sift_process_first_octave (filt, fdata);
while (err == 0) {
vl_sift_detect (filt) ;
VlSiftKeypoint const *keys = vl_sift_get_keypoints(filt) ;
int nkeys = vl_sift_get_nkeypoints(filt) ;
for (int i = 0; i < nkeys ; ++i) {
VlSiftKeypoint const *key = keys + i;
double angles [4] ;
int nangles = 0;
if (do_angle) {
nangles = vl_sift_calc_keypoint_orientations(filt, angles, key) ;
}
else {
nangles = 1;
angles[0] = 0;
}
for (int q = 0 ; q < nangles ; ++q) {
list->push_back(Feature());
Feature &f = list->back();
f.desc.resize(DIM);
/* compute descriptor (if necessary) */
vl_sift_calc_keypoint_descriptor(filt, &f.desc[0], key, angles[q]) ;
BOOST_FOREACH(float &v, f.desc) {
/*
v = round(v * SIFT_RANGE);
if (v > SIFT_RANGE) v = SIFT_RANGE;
*/
v *= 2;
if (v > 1.0) v = 1.0;
}
f.scale = image.getScale();
f.x = key->x;
f.y = key->y;
f.dir = angles[q] / M_PI / 2;
f.size = key->sigma * magnif;
if ((entropy(f.desc) < e_th) || !checkBlackList(f.desc)) {
list->pop_back();
}
}
}
err = vl_sift_process_next_octave (filt) ;
}
vl_sift_delete (filt) ;
delete [] fdata;
}
static PyObject *sift(PyObject *self, PyObject *args, PyObject *kwargs)
{
PyObject *input, *input_frames = NULL;
PyArrayObject *matin, *out_descr, *out_frames;
/* Input arguments */
static char *kwlist[] = {"input", "Octave", "Levels", "FirstOctave", "Frames",
"PeakThresh", "EdgeThresh", "NormThresh", "Orientations", "Verbose", NULL};
enum {IN_I=0,IN_END} ;
enum {OUT_FRAMES=0, OUT_DESCRIPTORS} ;
int verbose = 0 ;
int opt ;
int next = IN_END ;
int nout = 2;
vl_sift_pix const *data ;
int M, N ;
int O = - 1 ;
int S = 3 ;
int o_min = 0 ;
double edge_thresh = -1 ;
double peak_thresh = -1 ;
double norm_thresh = -1 ;
PyArrayObject *ikeys_array = 0 ;
double *ikeys = 0 ;
int nikeys = -1 ;
vl_bool force_orientations = 0 ;
// VL_USE_MATLAB_ENV ;
/* Parse Python tuples into their appropriate variables */
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|iiiOiiiii", kwlist, &matin, &O, &S, &o_min, &input_frames,
&peak_thresh, &edge_thresh, &norm_thresh, &force_orientations, &verbose))
return NULL;
// matin = (PyArrayObject *) PyArray_ContiguousFromObject(input, PyArray_FLOAT, 2, 2);
//if (matin == NULL)
// return NULL;
/* -----------------------------------------------------------------
* Check the arguments
* -------------------------------------------------------------- */
if (matin->nd != 2 || matin->descr->type_num != PyArray_FLOAT) {
printf("I must be a 2d matrix of dtype float32\n") ;
return NULL;
}
// Pointer to the data array in matin
//data = (vl_sift_pix *) pyvector_to_Carrayptrs(matin);
// vl_sift_pix is float!
data = (vl_sift_pix *) matin->data;
M = matin->dimensions[0];
N = matin->dimensions[1];
if (input_frames != NULL) {
ikeys_array = (PyArrayObject *) PyArray_ContiguousFromObject(input_frames, PyArray_FLOAT, 2, 2);
if (ikeys_array->dimensions[0] != 4) {
printf("'Frames' must be a 4 x N matrix.x\n");
return NULL;
}
nikeys = ikeys_array->dimensions[1];
ikeys = (double *) ikeys_array->data;
qsort (ikeys, nikeys, 4 * sizeof(double), korder);
}
/* -----------------------------------------------------------------
* Do job
* -------------------------------------------------------------- */
{
VlSiftFilt *filt ;
vl_bool first ;
double *frames = 0 ;
vl_uint8 *descr = 0 ;
int nframes = 0, reserved = 0, i,j,q ;
/* create a filter to process the image */
filt = vl_sift_new (M, N, O, S, o_min) ;
if (peak_thresh >= 0) vl_sift_set_peak_thresh (filt, peak_thresh) ;
if (edge_thresh >= 0) vl_sift_set_edge_thresh (filt, edge_thresh) ;
if (norm_thresh >= 0) vl_sift_set_norm_thresh (filt, norm_thresh) ;
if (verbose) {
printf("siftmx: filter settings:\n") ;
printf("siftpy: octaves (O) = %d\n",
vl_sift_get_octave_num (filt)) ;
printf("siftpy: levels (S) = %d\n",
vl_sift_get_level_num (filt)) ;
printf("siftpy: first octave (o_min) = %d\n",
vl_sift_get_octave_first (filt)) ;
printf("siftpy: edge thresh = %g\n",
vl_sift_get_edge_thresh (filt)) ;
printf("siftpy: peak thresh = %g\n",
vl_sift_get_peak_thresh (filt)) ;
printf("siftpy: norm thresh = %g\n",
vl_sift_get_norm_thresh (filt)) ;
printf("siftpy: will force orientations? %s\n",
force_orientations ? "yes" : "no") ;
}
Py_BEGIN_ALLOW_THREADS
/* ...............................................................
* Process each octave
* ............................................................ */
i = 0 ;
first = 1 ;
while (1) {
int err ;
VlSiftKeypoint const *keys = 0 ;
int nkeys = 0 ;
if (verbose) {
printf ("siftpy: processing octave %d\n",
vl_sift_get_octave_index (filt)) ;
}
/* Calculate the GSS for the next octave .................... */
if (first) {
err = vl_sift_process_first_octave (filt, data) ;
first = 0 ;
} else {
err = vl_sift_process_next_octave (filt) ;
}
if (err) break ;
if (verbose > 1) {
printf("siftpy: GSS octave %d computed\n",
vl_sift_get_octave_index (filt));
}
/* Run detector ............................................. */
if (nikeys < 0) {
vl_sift_detect (filt) ;
keys = vl_sift_get_keypoints (filt) ;
nkeys = vl_sift_get_keypoints_num (filt) ;
i = 0 ;
if (verbose > 1) {
printf ("siftpy: detected %d (unoriented) keypoints\n", nkeys) ;
}
} else {
nkeys = nikeys ;
}
/* For each keypoint ........................................ */
for (; i < nkeys ; ++i) {
double angles [4] ;
int nangles ;
VlSiftKeypoint ik ;
VlSiftKeypoint const *k ;
/* Obtain keypoint orientations ........................... */
if (nikeys >= 0) {
vl_sift_keypoint_init (filt, &ik,
ikeys [4 * i + 1] - 1,
ikeys [4 * i + 0] - 1,
ikeys [4 * i + 2]) ;
if (ik.o != vl_sift_get_octave_index (filt)) {
break ;
}
k = &ik ;
/* optionally compute orientations too */
if (force_orientations) {
nangles = vl_sift_calc_keypoint_orientations
(filt, angles, k) ;
} else {
angles [0] = VL_PI / 2 - ikeys [4 * i + 3] ;
nangles = 1 ;
}
} else {
k = keys + i ;
nangles = vl_sift_calc_keypoint_orientations
(filt, angles, k) ;
}
/* For each orientation ................................... */
for (q = 0 ; q < nangles ; ++q) {
vl_sift_pix buf [128] ;
vl_sift_pix rbuf [128] ;
/* compute descriptor (if necessary) */
if (nout > 1) {
vl_sift_calc_keypoint_descriptor
(filt, buf, k, angles [q]) ;
transpose_descriptor (rbuf, buf) ;
}
/* make enough room for all these keypoints and more */
if (reserved < nframes + 1) {
reserved += 2 * nkeys ;
frames = malloc (4 * sizeof(double) * reserved) ;
if (nout > 1) {
descr = malloc (128 * sizeof(vl_uint8) * reserved) ;
}
}
/* Save back with MATLAB conventions. Notice tha the input
* image was the transpose of the actual image. */
frames [4 * nframes + 0] = k -> y + 1 ;
frames [4 * nframes + 1] = k -> x + 1 ;
frames [4 * nframes + 2] = k -> sigma ;
frames [4 * nframes + 3] = VL_PI / 2 - angles [q] ;
if (nout > 1) {
for (j = 0 ; j < 128 ; ++j) {
double x = 512.0 * rbuf [j] ;
x = (x < 255.0) ? x : 255.0 ;
descr [128 * nframes + j] = (vl_uint8) (x) ;
}
}
++ nframes ;
} /* next orientation */
} /* next keypoint */
} /* next octave */
if (verbose) {
printf ("siftpy: found %d keypoints\n", nframes) ;
}
/* ...............................................................
* Save back
* ............................................................ */
Py_END_ALLOW_THREADS
{
int dims [2] ;
/* create an empty array */
dims [0] = nframes ;
dims [1] = 4 ;
// We are allocating new memory here because its the only way to make
// sure that it will get free()ed when there are no more references
out_frames = (PyArrayObject*) PyArray_FromDims(2, dims, PyArray_DOUBLE);
memcpy((double*) out_frames->data, frames, 4 * nframes * sizeof(double));
dims [0] = nframes ; // Numpy Array uses row format, Matlab uses column format
dims [1] = 128 ;
out_descr = (PyArrayObject*) PyArray_FromDims(2, dims, PyArray_UBYTE);
memcpy((vl_uint8 *) out_descr->data, descr, 128 * nframes * sizeof(vl_uint8) );
}
/* cleanup */
vl_sift_delete (filt) ;
free(frames);
free(descr);
} /* end: do job */
return Py_BuildValue("(OO)",PyArray_Return(out_frames), PyArray_Return(out_descr));
}
static bool SIFTDetector(const Image<unsigned char>& I,
std::vector<SIOPointFeature>& feats,
std::vector<Descriptor<type,128> >& descs,
bool bDezoom = false,
bool bRootSift = false,
float dPeakThreshold = 0.04f)
{
// First Octave Index.
int firstOctave = (bDezoom == true) ? -1 : 0;
// Number of octaves.
int numOctaves = 6;
// Number of scales per octave.
int numScales = 3;
// Max ratio of Hessian eigenvalues.
float edgeThresh = 10.0f;
// Min contrast.
float peakThresh = dPeakThreshold;
int w=I.Width(), h=I.Height();
//Convert to float
Image<float> If( I.GetMat().cast<float>() );
vl_constructor();
VlSiftFilt *filt = vl_sift_new(w,h,numOctaves,numScales,firstOctave);
if (edgeThresh >= 0)
vl_sift_set_edge_thresh(filt, edgeThresh);
if (peakThresh >= 0)
vl_sift_set_peak_thresh(filt, 255*peakThresh/numScales);
vl_sift_process_first_octave(filt, If.data());
vl_sift_pix descr[128];
Descriptor<type, 128> descriptor;
while (true) {
vl_sift_detect(filt);
VlSiftKeypoint const *keys = vl_sift_get_keypoints(filt);
int nkeys = vl_sift_get_nkeypoints(filt);
for (int i=0;i<nkeys;++i) {
double angles [4];
int nangles=vl_sift_calc_keypoint_orientations(filt,angles,keys+i);
for (int q=0 ; q < nangles ; ++q) {
vl_sift_calc_keypoint_descriptor(filt,descr, keys+i, angles [q]);
SIOPointFeature fp;
fp.x() = keys[i].x;
fp.y() = keys[i].y;
fp.scale() = keys[i].sigma;
fp.orientation() = static_cast<float>(angles[q]);
siftDescToFloat(descr, descriptor, bRootSift);
descs.push_back(descriptor);
feats.push_back(fp);
}
}
if (vl_sift_process_next_octave(filt))
break; // Last octave
}
vl_sift_delete(filt);
vl_destructor();
return true;
}
void
mexFunction(int nout, mxArray *out[],
int nin, const mxArray *in[])
{
enum {IN_I=0,IN_END} ;
enum {OUT_FRAMES=0, OUT_DESCRIPTORS} ;
int verbose = 0 ;
int opt ;
int next = IN_END ;
mxArray const *optarg ;
vl_sift_pix const *data ;
int M, N ;
int O = - 1 ;
int S = 3 ;
int o_min = 0 ;
double edge_thresh = -1 ;
double peak_thresh = -1 ;
double norm_thresh = -1 ;
double magnif = -1 ;
double window_size = -1 ;
mxArray *ikeys_array = 0 ;
double *ikeys = 0 ;
int nikeys = -1 ;
vl_bool force_orientations = 0 ;
vl_bool floatDescriptors = 0 ;
VL_USE_MATLAB_ENV ;
/* -----------------------------------------------------------------
* Check the arguments
* -------------------------------------------------------------- */
if (nin < 1) {
mexErrMsgTxt("One argument required.") ;
} else if (nout > 2) {
mexErrMsgTxt("Too many output arguments.");
}
if (mxGetNumberOfDimensions (in[IN_I]) != 2 ||
mxGetClassID (in[IN_I]) != mxSINGLE_CLASS ) {
mexErrMsgTxt("I must be a matrix of class SINGLE") ;
}
data = (vl_sift_pix*) mxGetData (in[IN_I]) ;
M = mxGetM (in[IN_I]) ;
N = mxGetN (in[IN_I]) ;
while ((opt = vlmxNextOption (in, nin, options, &next, &optarg)) >= 0) {
switch (opt) {
case opt_verbose :
++ verbose ;
break ;
case opt_octaves :
if (!vlmxIsPlainScalar(optarg) || (O = (int) *mxGetPr(optarg)) < 0) {
mexErrMsgTxt("'Octaves' must be a positive integer.") ;
}
break ;
case opt_levels :
if (! vlmxIsPlainScalar(optarg) || (S = (int) *mxGetPr(optarg)) < 1) {
mexErrMsgTxt("'Levels' must be a positive integer.") ;
}
break ;
case opt_first_octave :
if (!vlmxIsPlainScalar(optarg)) {
mexErrMsgTxt("'FirstOctave' must be an integer") ;
}
o_min = (int) *mxGetPr(optarg) ;
break ;
case opt_edge_thresh :
if (!vlmxIsPlainScalar(optarg) || (edge_thresh = *mxGetPr(optarg)) < 1) {
mexErrMsgTxt("'EdgeThresh' must be not smaller than 1.") ;
}
break ;
case opt_peak_thresh :
if (!vlmxIsPlainScalar(optarg) || (peak_thresh = *mxGetPr(optarg)) < 0) {
mexErrMsgTxt("'PeakThresh' must be a non-negative real.") ;
}
break ;
case opt_norm_thresh :
if (!vlmxIsPlainScalar(optarg) || (norm_thresh = *mxGetPr(optarg)) < 0) {
mexErrMsgTxt("'NormThresh' must be a non-negative real.") ;
}
break ;
case opt_magnif :
if (!vlmxIsPlainScalar(optarg) || (magnif = *mxGetPr(optarg)) < 0) {
mexErrMsgTxt("'Magnif' must be a non-negative real.") ;
}
break ;
case opt_window_size :
if (!vlmxIsPlainScalar(optarg) || (window_size = *mxGetPr(optarg)) < 0) {
mexErrMsgTxt("'WindowSize' must be a non-negative real.") ;
}
break ;
case opt_frames :
if (!vlmxIsMatrix(optarg, 4, -1)) {
mexErrMsgTxt("'Frames' must be a 4 x N matrix.x") ;
}
ikeys_array = mxDuplicateArray (optarg) ;
nikeys = mxGetN (optarg) ;
ikeys = mxGetPr (ikeys_array) ;
if (! check_sorted (ikeys, nikeys)) {
qsort (ikeys, nikeys, 4 * sizeof(double), korder) ;
}
break ;
case opt_orientations :
force_orientations = 1 ;
break ;
case opt_float_descriptors :
floatDescriptors = 1 ;
break ;
default :
abort() ;
}
}
/* -----------------------------------------------------------------
* Do job
* -------------------------------------------------------------- */
{
VlSiftFilt *filt ;
vl_bool first ;
double *frames = 0 ;
void *descr = 0 ;
int nframes = 0, reserved = 0, i,j,q ;
/* create a filter to process the image */
filt = vl_sift_new (M, N, O, S, o_min) ;
if (peak_thresh >= 0) vl_sift_set_peak_thresh (filt, peak_thresh) ;
if (edge_thresh >= 0) vl_sift_set_edge_thresh (filt, edge_thresh) ;
if (norm_thresh >= 0) vl_sift_set_norm_thresh (filt, norm_thresh) ;
if (magnif >= 0) vl_sift_set_magnif (filt, magnif) ;
if (window_size >= 0) vl_sift_set_window_size (filt, window_size) ;
if (verbose) {
mexPrintf("vl_sift: filter settings:\n") ;
mexPrintf("vl_sift: octaves (O) = %d\n",
vl_sift_get_noctaves (filt)) ;
mexPrintf("vl_sift: levels (S) = %d\n",
vl_sift_get_nlevels (filt)) ;
mexPrintf("vl_sift: first octave (o_min) = %d\n",
vl_sift_get_octave_first (filt)) ;
mexPrintf("vl_sift: edge thresh = %g\n",
vl_sift_get_edge_thresh (filt)) ;
mexPrintf("vl_sift: peak thresh = %g\n",
vl_sift_get_peak_thresh (filt)) ;
mexPrintf("vl_sift: norm thresh = %g\n",
vl_sift_get_norm_thresh (filt)) ;
mexPrintf("vl_sift: window size = %g\n",
vl_sift_get_window_size (filt)) ;
mexPrintf("vl_sift: float descriptor = %d\n",
floatDescriptors) ;
mexPrintf((nikeys >= 0) ?
"vl_sift: will source frames? yes (%d read)\n" :
"vl_sift: will source frames? no\n", nikeys) ;
mexPrintf("vl_sift: will force orientations? %s\n",
force_orientations ? "yes" : "no") ;
}
/* ...............................................................
* Process each octave
* ............................................................ */
i = 0 ;
first = 1 ;
while (1) {
int err ;
VlSiftKeypoint const* keys = 0 ;
int nkeys = 0 ;
if (verbose) {
mexPrintf ("vl_sift: processing octave %d\n",
vl_sift_get_octave_index (filt)) ;
}
/* Calculate the GSS for the next octave .................... */
if (first) {
err = vl_sift_process_first_octave (filt, data) ;
first = 0 ;
} else {
err = vl_sift_process_next_octave (filt) ;
}
if (err) break ;
if (verbose > 1) {
mexPrintf("vl_sift: GSS octave %d computed\n",
vl_sift_get_octave_index (filt));
}
/* Run detector ............................................. */
if (nikeys < 0) {
vl_sift_detect (filt) ;
keys = vl_sift_get_keypoints (filt) ;
nkeys = vl_sift_get_nkeypoints (filt) ;
i = 0 ;
if (verbose > 1) {
printf ("vl_sift: detected %d (unoriented) keypoints\n", nkeys) ;
}
} else {
nkeys = nikeys ;
}
/* For each keypoint ........................................ */
for (; i < nkeys ; ++i) {
double angles [4] ;
int nangles ;
VlSiftKeypoint ik ;
VlSiftKeypoint const *k ;
/* Obtain keypoint orientations ........................... */
if (nikeys >= 0) {
vl_sift_keypoint_init (filt, &ik,
ikeys [4 * i + 1] - 1,
ikeys [4 * i + 0] - 1,
ikeys [4 * i + 2]) ;
if (ik.o != vl_sift_get_octave_index (filt)) {
break ;
}
k = &ik ;
/* optionally compute orientations too */
if (force_orientations) {
nangles = vl_sift_calc_keypoint_orientations
(filt, angles, k) ;
} else {
angles [0] = VL_PI / 2 - ikeys [4 * i + 3] ;
nangles = 1 ;
}
} else {
k = keys + i ;
nangles = vl_sift_calc_keypoint_orientations
(filt, angles, k) ;
}
/* For each orientation ................................... */
for (q = 0 ; q < nangles ; ++q) {
vl_sift_pix buf [128] ;
vl_sift_pix rbuf [128] ;
/* compute descriptor (if necessary) */
if (nout > 1) {
vl_sift_calc_keypoint_descriptor (filt, buf, k, angles [q]) ;
transpose_descriptor (rbuf, buf) ;
}
/* make enough room for all these keypoints and more */
if (reserved < nframes + 1) {
reserved += 2 * nkeys ;
frames = mxRealloc (frames, 4 * sizeof(double) * reserved) ;
if (nout > 1) {
if (! floatDescriptors) {
descr = mxRealloc (descr, 128 * sizeof(vl_uint8) * reserved) ;
} else {
descr = mxRealloc (descr, 128 * sizeof(float) * reserved) ;
}
}
}
/* Save back with MATLAB conventions. Notice tha the input
* image was the transpose of the actual image. */
frames [4 * nframes + 0] = k -> y + 1 ;
frames [4 * nframes + 1] = k -> x + 1 ;
frames [4 * nframes + 2] = k -> sigma ;
frames [4 * nframes + 3] = VL_PI / 2 - angles [q] ;
if (nout > 1) {
if (! floatDescriptors) {
for (j = 0 ; j < 128 ; ++j) {
float x = 512.0F * rbuf [j] ;
x = (x < 255.0F) ? x : 255.0F ;
((vl_uint8*)descr) [128 * nframes + j] = (vl_uint8) x ;
}
} else {
for (j = 0 ; j < 128 ; ++j) {
float x = 512.0F * rbuf [j] ;
((float*)descr) [128 * nframes + j] = x ;
}
}
}
++ nframes ;
} /* next orientation */
} /* next keypoint */
} /* next octave */
if (verbose) {
mexPrintf ("vl_sift: found %d keypoints\n", nframes) ;
}
/* ...............................................................
* Save back
* ............................................................ */
{
mwSize dims [2] ;
/* create an empty array */
dims [0] = 0 ;
dims [1] = 0 ;
out[OUT_FRAMES] = mxCreateNumericArray
(2, dims, mxDOUBLE_CLASS, mxREAL) ;
/* set array content to be the frames buffer */
dims [0] = 4 ;
dims [1] = nframes ;
mxSetPr (out[OUT_FRAMES], frames) ;
mxSetDimensions (out[OUT_FRAMES], dims, 2) ;
if (nout > 1) {
/* create an empty array */
dims [0] = 0 ;
dims [1] = 0 ;
out[OUT_DESCRIPTORS]= mxCreateNumericArray
(2, dims,
floatDescriptors ? mxSINGLE_CLASS : mxUINT8_CLASS,
mxREAL) ;
/* set array content to be the descriptors buffer */
dims [0] = 128 ;
dims [1] = nframes ;
mxSetData (out[OUT_DESCRIPTORS], descr) ;
mxSetDimensions (out[OUT_DESCRIPTORS], dims, 2) ;
}
}
/* cleanup */
vl_sift_delete (filt) ;
if (ikeys_array)
mxDestroyArray(ikeys_array) ;
} /* end: do job */
}
/**
* Calculates and returns the SIFT keypoints for a camera frame.
*
* @param keypoints A pointer to a pointer which will be modified to point to the array of keypoints.
* @param num_keypoints The number of SIFT keypoints, and the size of the regions array
* @param frame_buffer The camera's frame buffer
*
* @return MAR_ERROR_NONE on success, an error code on failure.
*/
MAR_PUBLIC
mar_error_code mar_sift_get_keypoints(mar_sift_keypoint **keypoints, int *num_keypoints, unsigned char *frame_buffer)
{
int i, j, sift_status, norientations, num_points;
VlSiftKeypoint const *points;
double orientations[4];
vl_sift_pix descriptors[MAR_SIFT_NBP * MAR_SIFT_NBP * MAR_SIFT_NBO];
// Build grayscale image
for (i = 0; i < sift_image_width * sift_image_height; i++)
{
sift_image_buffer[i] = (frame_buffer[i*3 + 0] * 0.3 + frame_buffer[i*3 + 1] * 0.59 + frame_buffer[i*3 + 2] * 0.11) / 255.0;
}
// Filter the image
*num_keypoints = 0;
sift_status = vl_sift_process_first_octave(sift_filter, sift_image_buffer);
while (sift_status != VL_ERR_EOF)
{
vl_sift_detect(sift_filter);
// Get the SIFT keypoints
points = vl_sift_get_keypoints(sift_filter);
num_points = vl_sift_get_nkeypoints(sift_filter);
// Check if the buffer is too small
if (sift_keypoints_size < *num_keypoints + num_points * 4)
{
sift_keypoints_size = *num_keypoints + num_points * 4;
sift_keypoints = realloc(sift_keypoints, sizeof(mar_sift_keypoint) * (*num_keypoints + num_points * 4));
if (sift_keypoints == NULL)
{
return MAR_ERROR_MALLOC;
}
}
// Iterate through the keypoints
for (i = 0; i < num_points; i++)
{
// Iterate through the orientations
norientations = vl_sift_calc_keypoint_orientations(sift_filter, orientations, &(points[i]));
for (j = 0; j < norientations; j++)
{
vl_sift_calc_keypoint_descriptor(sift_filter, descriptors, &(points[i]), orientations[j]);
// Add the sift keypoint
assert(sizeof(vl_sift_pix) == sizeof(float));
sift_keypoints[*num_keypoints].x = points[i].x;
sift_keypoints[*num_keypoints].y = points[i].y;
sift_keypoints[*num_keypoints].radius = points[i].s;
sift_keypoints[*num_keypoints].angle = points[i].sigma;
memcpy(sift_keypoints[*num_keypoints].descriptor, descriptors, MAR_SIFT_NBO * MAR_SIFT_NBP * MAR_SIFT_NBP * sizeof(vl_sift_pix));
(*num_keypoints)++;
}
}
sift_status = vl_sift_process_next_octave(sift_filter);
}
*keypoints = sift_keypoints;
return MAR_ERROR_NONE;
}
/** @brief SIFT driver entry point
**/
int Sift::Detect()
{
/* algorithm parameters */
double edge_thresh = -1 ;
double peak_thresh = -1 ;
double magnif = -1 ;
int O = -1, S = 3, omin = -1 ;
vl_bool err = VL_ERR_OK ;
vl_bool force_orientations = 0 ;
VlSiftFilt *filt = 0 ;
vl_size q ;
int i ;
vl_bool first ;
TimeMeasureBase& measure = *TimeMeasureBase::getInstance();
measure.startTimer("Sift::Detect()");
#define WERR(name,op) \
if (err == VL_ERR_OVERFLOW) { \
snprintf(err_msg, sizeof(err_msg), \
"Output file name too long.") ; \
goto done ; \
} else if (err) { \
snprintf(err_msg, sizeof(err_msg), \
"Could not open '%s' for " #op, name) ; \
goto done ; \
}
/* ...............................................................
* Make filter
* ............................................................ */
filt = vl_sift_new (pim.width, pim.height, O, S, omin) ;
Logger::debug(Logger::SIFT, "new filter(vl_sift_new) created:%x", filt) ;
if (edge_thresh >= 0) vl_sift_set_edge_thresh (filt, edge_thresh) ;
if (peak_thresh >= 0) vl_sift_set_peak_thresh (filt, peak_thresh) ;
if (magnif >= 0) vl_sift_set_magnif (filt, magnif) ;
if (!filt)
{
Logger::error(Logger::SIFT, "Detect: could not create SIFT-fiter.");
throw SiftException("could not create SIFT-fiter.");
}
Logger::debug(Logger::SIFT, "sift: filter settings:") ;
Logger::debug(Logger::SIFT, "sift: octaves (O) = %d",
vl_sift_get_noctaves (filt)) ;
Logger::debug(Logger::SIFT, "sift: levels (S) = %d",
vl_sift_get_nlevels (filt)) ;
Logger::debug(Logger::SIFT, "sift: first octave (o_min) = %d",
vl_sift_get_octave_first (filt)) ;
Logger::debug(Logger::SIFT, "sift: edge thresh = %g",
vl_sift_get_edge_thresh (filt)) ;
Logger::debug(Logger::SIFT, "sift: peak thresh = %g",
vl_sift_get_peak_thresh (filt)) ;
Logger::debug(Logger::SIFT, "sift: magnif = %g",
vl_sift_get_magnif (filt)) ;
Logger::debug(Logger::SIFT, "sift: will force orientations? %s",
force_orientations ? "yes" : "no") ;
/* ...............................................................
* Process each octave
* ............................................................ */
i = 0 ;
first = 1 ;
while (1)
{
VlSiftKeypoint const *keys = 0 ;
int nkeys ;
Logger::debug(Logger::SIFT, "sift: computing octave");
/* calculate the GSS for the next octave .................... */
measure.startTimer("process_octave");
if (first)
{
measure.startTimer("process_f_octave");
first = 0 ;
err = vl_sift_process_first_octave(filt, fdata) ;
measure.stopTimer("process_f_octave");
}
else
{
measure.startTimer("process_n_octave");
err = vl_sift_process_next_octave(filt);
measure.stopTimer("process_n_octave");
}
measure.stopTimer("process_octave");
if (err)
{
err = VL_ERR_OK ;
break ;
}
Logger::debug(Logger::SIFT, "sift: GSS octave %d computed",
vl_sift_get_octave_index (filt));
/* run detector ............................................. */
measure.startTimer("sift_detect");
vl_sift_detect (filt) ;
measure.stopTimer("sift_detect");
keys = vl_sift_get_keypoints(filt) ;
nkeys = vl_sift_get_nkeypoints(filt) ;
i = 0 ;
Logger::debug(Logger::SIFT, "sift: detected %d (unoriented) keypoints", nkeys) ;
/* for each keypoint ........................................ */
for (; i < nkeys ; ++i)
{
measure.startTimer("per_kpoint");
double angles [4] ;
int nangles ;
//VlSiftKeypoint ik ;
VlSiftKeypoint const *k ;
/* obtain keypoint orientations ........................... */
k = keys + i ;
nangles = vl_sift_calc_keypoint_orientations
(filt, angles, k) ;
/* for each orientation ................................... */
for (q = 0 ; q < (unsigned) nangles ; ++q)
{
KeyPointDescriptor newKeyPoint;
/* compute descriptor (if necessary) */
//if (out.active || dsc.active) {
vl_sift_calc_keypoint_descriptor(filt, newKeyPoint.descr, k, angles [q]) ;
//}
newKeyPoint.keypoint = *k;
newKeyPoint.angle = angles[q];
detected_keypoints.push_back(newKeyPoint);
}
measure.stopTimer("per_kpoint");
}
}
/* ...............................................................
* Finish up
* ............................................................ */
/* release filter */
if (filt)
{
Logger::debug(Logger::SIFT, "freeing filt: %x", filt);
vl_sift_delete (filt) ;
filt = 0 ;
}
measure.stopTimer("Sift::Detect()");
measure.printStatistic();
/* quit */
return 0;
}
void
mexFunction(int nout, mxArray *out[],
int nin, const mxArray *in[])
{
enum {IN_I=0,IN_END} ;
enum {OUT_FRAMES=0, OUT_DESCRIPTORS} ;
int verbose = 0 ;
int opt ;
int next = IN_END ;
mxArray const *optarg ;
vl_sift_pix const *data ;
int M, N ;
int O = - 1 ;
int S = 3 ;
int o_min = 0 ;
double edge_thresh = -1 ;
double peak_thresh = -1 ;
double norm_thresh = -1 ;
double magnif = -1 ;
double window_size = -1 ;
mxArray *ikeys_array = 0 ;
double *ikeys = 0 ;
int nikeys = -1 ;
vl_bool force_orientations = 0 ;
vl_bool floatDescriptors = 0 ;
VL_USE_MATLAB_ENV ;
/* -----------------------------------------------------------------
* Check the arguments
* -------------------------------------------------------------- */
if (nin < 1) {
mexErrMsgTxt("One argument required.") ;
} else if (nout > 2) {
mexErrMsgTxt("Too many output arguments.");
}
if (mxGetNumberOfDimensions (in[IN_I]) != 2 ||
mxGetClassID (in[IN_I]) != mxSINGLE_CLASS ) {
mexErrMsgTxt("I must be a matrix of class SINGLE") ;
}
data = (vl_sift_pix*) mxGetData (in[IN_I]) ;
M = mxGetM (in[IN_I]) ;
N = mxGetN (in[IN_I]) ;
while ((opt = vlmxNextOption (in, nin, options, &next, &optarg)) >= 0) {
switch (opt) {
case opt_verbose :
++ verbose ;
break ;
case opt_frames :
if (!vlmxIsMatrix(optarg, 4, -1)) {
mexErrMsgTxt("'Frames' must be a 4 x N matrix.") ;
}
ikeys_array = mxDuplicateArray (optarg) ;
nikeys = mxGetN (optarg) ;
ikeys = mxGetPr (ikeys_array) ;
if (! check_sorted (ikeys, nikeys)) {
qsort (ikeys, nikeys, 4 * sizeof(double), korder) ;
}
break ;
default :
mexPrintf("F**k you!");
abort() ;
}
}
/* -----------------------------------------------------------------
* Do job
* -------------------------------------------------------------- */
{
VlSiftFilt *filt ;
vl_bool first ;
double *frames = 0 ;
void *descr = 0 ;
int nframes = 0, reserved = 0, i,j,q ;
/* create a filter to process the image */
filt = vl_sift_new (M, N, O, S, o_min) ;
//mexPrintf("%f %f %f \n%f %f %f %f %f\n",(float)O,(float)S,(float)o_min,(float)peak_thresh
// ,(float)edge_thresh,(float)norm_thresh,(float)magnif,(float)window_size);
/* ...............................................................
* Process each octave
* ............................................................ */
i = 0 ;
first = 1 ;
while (first == 1) {
int err ;
VlSiftKeypoint const *keys = 0 ;
int nkeys = 0 ;
err = vl_sift_process_first_octave (filt, data) ;
first = 0 ;
if (err) break ;
/* Run detector ............................................. */
nkeys = nikeys ;
//mexPrintf("Zhu: entering sweeping nkeys, nkeys = %d, i = %d \n", nkeys, i);
/* For each keypoint ........................................ */
for (; i < nkeys ; ++i) {
int h;
vl_sift_pix buf[128];
vl_sift_pix rbuf[128];
double angle;
VlSiftKeypoint ik ;
VlSiftKeypoint const *k ;
/* Obtain keypoint orientations ........................... */
vl_sift_keypoint_init (filt, &ik,
ikeys [4 * i + 1] - 1,
ikeys [4 * i + 0] - 1,
ikeys [4 * i + 2]) ;
//mexPrintf("ikeys: [%f, %f, %f]\n", (float)(ikeys [4 * i + 1] - 1), (float)(ikeys [4 * i + 0] - 1), (float)(ikeys [4 * i + 2]) );
k = &ik ;
/* optionally compute orientations too */
angle = VL_PI / 2 - ikeys [4 * i + 3] ;
q = 0;
/* compute descriptor (if necessary) */
//int h;
//mexPrintf("M = %d, N = %d.\n",M,N);
//for (h = 0; h < 300; h++)
//{
// mexPrintf("%f ",data[h]);
// if (h % 8 == 7) mexPrintf("\n");
//}
if (nout > 1) {
//mexPrintf("angles = %f, x = %f(%d), y = %f(%d), s = %f(%d), o = %d, sigma = %f.\n buf = [",
//angle,k->x,k->ix,k->y,k->iy,k->s,k->is,k->o,k->sigma);
vl_sift_calc_keypoint_descriptor (filt, buf, k, angle) ;
//for (h = 0; h < 128; h++)
//{
// mexPrintf("%f ",(float)buf[h]);
// if (h % 8 == 7) mexPrintf("\n");
//}
//mexPrintf("...].\nrbuf = [");
transpose_descriptor (rbuf, buf) ;
//for (h = 0; h < 128; h++)
//{
// mexPrintf("%f ",(float)rbuf[h]);
// if (h % 8 == 7) mexPrintf("\n");
//}
//mexPrintf("...].\n");
}
/* make enough room for all these keypoints and more */
if (reserved < nframes + 1) {
reserved += 2 * nkeys ;
frames = mxRealloc (frames, 4 * sizeof(double) * reserved) ;
if (nout > 1) {
if (! floatDescriptors) {
descr = mxRealloc (descr, 128 * sizeof(vl_uint8) * reserved) ;
} else {
descr = mxRealloc (descr, 128 * sizeof(float) * reserved) ;
}
}
}
/* Save back with MATLAB conventions. Notice tha the input
* image was the transpose of the actual image. */
frames [4 * nframes + 0] = k -> y + 1 ;
frames [4 * nframes + 1] = k -> x + 1 ;
frames [4 * nframes + 2] = k -> sigma ;
frames [4 * nframes + 3] = VL_PI / 2 - angle;
//mexPrintf("Zhu: %d\n", nframes);
if (nout > 1) {
if (! floatDescriptors) {
for (j = 0 ; j < 128 ; ++j) {
float x = 512.0F * rbuf [j] ;
x = (x < 255.0F) ? x : 255.0F ;
((vl_uint8*)descr) [128 * nframes + j] = (vl_uint8) x ;
}
} else {
for (j = 0 ; j < 128 ; ++j) {
float x = 512.0F * rbuf [j] ;
((float*)descr) [128 * nframes + j] = x ;
}
}
}
++ nframes ;
/* next orientation */
} /* next keypoint */
//break;
//mexPrintf("Zhu: skip subsequent octave\n");
} /* next octave */
//mexPrintf("nframes_tot = %d\n",nframes);
/* ...............................................................
* Save back
* ............................................................ */
{
mwSize dims [2] ;
/* create an empty array */
dims [0] = 0 ;
dims [1] = 0 ;
out[OUT_FRAMES] = mxCreateNumericArray
(2, dims, mxDOUBLE_CLASS, mxREAL) ;
/* set array content to be the frames buffer */
dims [0] = 4 ;
dims [1] = nframes ;
mxSetPr (out[OUT_FRAMES], frames) ;
mxSetDimensions (out[OUT_FRAMES], dims, 2) ;
if (nout > 1) {
/* create an empty array */
dims [0] = 0 ;
dims [1] = 0 ;
out[OUT_DESCRIPTORS]= mxCreateNumericArray
(2, dims,
floatDescriptors ? mxSINGLE_CLASS : mxUINT8_CLASS,
mxREAL) ;
/* set array content to be the descriptors buffer */
dims [0] = 128 ;
dims [1] = nframes ;
mxSetData (out[OUT_DESCRIPTORS], descr) ;
mxSetDimensions (out[OUT_DESCRIPTORS], dims, 2) ;
}
}
/* cleanup */
vl_sift_delete (filt) ;
if (ikeys_array)
mxDestroyArray(ikeys_array) ;
} /* end: do job */
}
/** @brief SIFT driver entry point
**/
int
main(int argc, char **argv)
{
/* algorithm parameters */
double edge_thresh = -1 ;
double peak_thresh = -1 ;
double magnif = -1 ;
int O = -1, S = 3, omin = -1 ;
vl_bool err = VL_ERR_OK ;
char err_msg [1024] ;
int n ;
int exit_code = 0 ;
int verbose = 0 ;
vl_bool force_output = 0 ;
vl_bool force_orientations = 0 ;
VlFileMeta out = {1, "%.sift", VL_PROT_ASCII, "", 0} ;
VlFileMeta frm = {0, "%.frame", VL_PROT_ASCII, "", 0} ;
VlFileMeta dsc = {0, "%.descr", VL_PROT_ASCII, "", 0} ;
VlFileMeta met = {0, "%.meta", VL_PROT_ASCII, "", 0} ;
VlFileMeta gss = {0, "%.pgm", VL_PROT_ASCII, "", 0} ;
VlFileMeta ifr = {0, "%.frame", VL_PROT_ASCII, "", 0} ;
#define ERRF(msg, arg) { \
err = VL_ERR_BAD_ARG ; \
snprintf(err_msg, sizeof(err_msg), msg, arg) ; \
break ; \
}
#define ERR(msg) { \
err = VL_ERR_BAD_ARG ; \
snprintf(err_msg, sizeof(err_msg), msg) ; \
break ; \
}
/* -----------------------------------------------------------------
* Parse options
* -------------------------------------------------------------- */
while (!err) {
int ch = getopt_long(argc, argv, opts, longopts, 0) ;
/* If there are no files passed as input, print the help and settings */
if (ch == -1 && argc - optind == 0)
ch = 'h';
/* end of option list? */
if (ch == -1) break;
switch (ch) {
case '?' :
/* unkown option ............................................ */
ERRF("Invalid option '%s'.", argv [optind - 1]) ;
break ;
case ':' :
/* missing argument ......................................... */
ERRF("Missing mandatory argument for option '%s'.",
argv [optind - 1]) ;
break ;
case 'h' :
/* --help ................................................... */
printf (help_message, argv [0]) ;
printf ("SIFT filespec: `%s'\n", out.pattern) ;
printf ("Frames filespec: `%s'\n", frm.pattern) ;
printf ("Descriptors filespec: `%s'\n", dsc.pattern) ;
printf ("Meta filespec: `%s'\n", met.pattern) ;
printf ("GSS filespec: '%s'\n", gss.pattern) ;
printf ("Read frames filespec: '%s'\n", ifr.pattern) ;
printf ("Version: driver %s; libvl %s\n",
VL_XSTRINGIFY(VL_SIFT_DRIVER_VERSION),
vl_get_version_string()) ;
exit (0) ;
break ;
case 'v' :
/* --verbose ................................................ */
++ verbose ;
break ;
case 'o' :
/* --output ................................................ */
err = vl_file_meta_parse (&out, optarg) ;
if (err)
ERRF("The arguments of '%s' is invalid.", argv [optind - 1]) ;
force_output = 1 ;
break ;
case opt_frames :
/* --frames ................................................ */
err = vl_file_meta_parse (&frm, optarg) ;
if (err)
ERRF("The arguments of '%s' is invalid.", argv [optind - 1]) ;
break ;
case opt_descriptors :
/* --descriptor ............................................. */
err = vl_file_meta_parse (&dsc, optarg) ;
if (err)
ERRF("The arguments of '%s' is invalid.", argv [optind - 1]) ;
break;
case opt_meta :
/* --meta ................................................... */
err = vl_file_meta_parse (&met, optarg) ;
if (err)
ERRF("The arguments of '%s' is invalid.", argv [optind - 1]) ;
if (met.protocol != VL_PROT_ASCII)
ERR("meta file supports only ASCII protocol") ;
break ;
case opt_read_frames :
/* --read_frames ............................................ */
err = vl_file_meta_parse (&ifr, optarg) ;
if (err)
ERRF("The arguments of '%s' is invalid.", argv [optind - 1]) ;
break ;
case opt_gss :
/* --gss .................................................... */
err = vl_file_meta_parse (&gss, optarg) ;
if (err)
ERRF("The arguments of '%s' is invalid.", argv [optind - 1]) ;
break ;
case 'O' :
/* --octaves ............................................... */
n = sscanf (optarg, "%d", &O) ;
if (n == 0 || O < 0)
ERRF("The argument of '%s' must be a non-negative integer.",
argv [optind - 1]) ;
break ;
case 'S' :
/* --levels ............................................... */
n = sscanf (optarg, "%d", &S) ;
if (n == 0 || S < 0)
ERRF("The argument of '%s' must be a non-negative integer.",
argv [optind - 1]) ;
break ;
case opt_first_octave :
/* --first-octave ......................................... */
n = sscanf (optarg, "%d", &omin) ;
if (n == 0)
ERRF("The argument of '%s' must be an integer.",
argv [optind - 1]) ;
break ;
case opt_edge_thresh :
/* --edge-thresh ........................................... */
n = sscanf (optarg, "%lf", &edge_thresh) ;
if (n == 0 || edge_thresh < 1)
ERRF("The argument of '%s' must be not smaller than 1.",
argv [optind - 1]) ;
break ;
case opt_peak_thresh :
/* --edge-thresh ........................................... */
n = sscanf (optarg, "%lf", &peak_thresh) ;
if (n == 0 || peak_thresh < 0)
ERRF("The argument of '%s' must be a non-negative float.",
argv [optind - 1]) ;
break ;
case opt_magnif :
/* --magnif .............................................. */
n = sscanf (optarg, "%lf", &magnif) ;
if (n == 0 || magnif < 1)
ERRF("The argument of '%s' must be a non-negative float.",
argv [optind - 1]) ;
break ;
case opt_orientations :
/* --orientations ......................................... */
force_orientations = 1 ;
break ;
case 0 :
default :
/* should not get here ...................................... */
assert (0) ;
break ;
}
}
/* check for parsing errors */
if (err) {
fprintf(stderr, "%s: error: %s (%d)\n",
argv [0],
err_msg, err) ;
exit (1) ;
}
/* parse other arguments (filenames) */
argc -= optind ;
argv += optind ;
/*
if --output is not specified, specifying --frames or --descriptors
prevent the aggregate outout file to be produced.
*/
if (! force_output && (frm.active || dsc.active)) {
out.active = 0 ;
}
if (verbose > 1) {
#define PRNFO(name,fm) \
printf("sift: " name) ; \
printf("%3s ", (fm).active ? "yes" : "no") ; \
printf("%-6s ", vl_string_protocol_name ((fm).protocol)) ; \
printf("%-10s\n", (fm).pattern) ;
PRNFO("write aggregate . ", out) ;
PRNFO("write frames .... ", frm) ;
PRNFO("write descriptors ", dsc) ;
PRNFO("write meta ...... ", met) ;
PRNFO("write GSS ....... ", gss) ;
PRNFO("read frames .... ", ifr) ;
if (force_orientations)
printf("sift: will compute orientations\n") ;
}
/* ------------------------------------------------------------------
* Process one image per time
* --------------------------------------------------------------- */
while (argc--) {
char basename [1024] ;
char const *name = *argv++ ;
FILE *in = 0 ;
vl_uint8 *data = 0 ;
vl_sift_pix *fdata = 0 ;
VlPgmImage pim ;
VlSiftFilt *filt = 0 ;
int q, i ;
vl_bool first ;
double *ikeys = 0 ;
int nikeys = 0, ikeys_size = 0 ;
/* ...............................................................
* Determine files
* ............................................................ */
/* get basenmae from filename */
q = vl_string_basename (basename, sizeof(basename), name, 1) ;
err = (q >= sizeof(basename)) ;
if (err) {
snprintf(err_msg, sizeof(err_msg),
"Basename of '%s' is too long", name);
err = VL_ERR_OVERFLOW ;
goto done ;
}
if (verbose) {
printf ("sift: <== '%s'\n", name) ;
}
if (verbose > 1) {
printf ("sift: basename is '%s'\n", basename) ;
}
/* open input file */
in = fopen (name, "rb") ;
if (!in) {
err = VL_ERR_IO ;
snprintf(err_msg, sizeof(err_msg),
"Could not open '%s' for reading.", name) ;
goto done ;
}
/* ...............................................................
* Read data
* ............................................................ */
/* read PGM header */
err = vl_pgm_extract_head (in, &pim) ;
if (err) {
switch (vl_err_no) {
case VL_ERR_PGM_IO :
snprintf(err_msg, sizeof(err_msg),
"Cannot read from '%s'.", name) ;
err = VL_ERR_IO ;
break ;
case VL_ERR_PGM_INV_HEAD :
snprintf(err_msg, sizeof(err_msg),
"'%s' contains a malformed PGM header.", name) ;
err = VL_ERR_IO ;
goto done ;
}
}
if (verbose)
printf ("sift: image is %d by %d pixels\n",
pim. width,
pim. height) ;
/* allocate buffer */
data = malloc(vl_pgm_get_npixels (&pim) *
vl_pgm_get_bpp (&pim) * sizeof (vl_uint8) ) ;
fdata = malloc(vl_pgm_get_npixels (&pim) *
vl_pgm_get_bpp (&pim) * sizeof (vl_sift_pix)) ;
if (!data || !fdata) {
err = VL_ERR_ALLOC ;
snprintf(err_msg, sizeof(err_msg),
"Could not allocate enough memory.") ;
goto done ;
}
/* read PGM body */
err = vl_pgm_extract_data (in, &pim, data) ;
if (err) {
snprintf(err_msg, sizeof(err_msg), "PGM body malformed.") ;
err = VL_ERR_IO ;
goto done ;
}
/* convert data type */
for (q = 0 ; q < pim.width * pim.height ; ++q)
fdata [q] = data [q] ;
/* ...............................................................
* Optionally source keypoints
* ............................................................ */
#define WERR(name,op) \
if (err == VL_ERR_OVERFLOW) { \
snprintf(err_msg, sizeof(err_msg), \
"Output file name too long.") ; \
goto done ; \
} else if (err) { \
snprintf(err_msg, sizeof(err_msg), \
"Could not open '%s' for " #op, name) ; \
goto done ; \
}
if (ifr.active) {
/* open file */
err = vl_file_meta_open (&ifr, basename, "rb") ;
WERR(ifr.name, reading) ;
#define QERR \
if (err ) { \
snprintf (err_msg, sizeof(err_msg), \
"'%s' malformed", ifr.name) ; \
err = VL_ERR_IO ; \
goto done ; \
}
while (1) {
double x, y, s, th ;
/* read next guy */
err = vl_file_meta_get_double (&ifr, &x) ;
if (err == VL_ERR_EOF) break;
else QERR ;
err = vl_file_meta_get_double (&ifr, &y ) ; QERR ;
err = vl_file_meta_get_double (&ifr, &s ) ; QERR ;
err = vl_file_meta_get_double (&ifr, &th) ;
if (err == VL_ERR_EOF) break;
else QERR ;
/* make enough space */
if (ikeys_size < nikeys + 1) {
ikeys_size += 10000 ;
ikeys = realloc (ikeys, 4 * sizeof(double) * ikeys_size) ;
}
/* add the guy to the buffer */
ikeys [4 * nikeys + 0] = x ;
ikeys [4 * nikeys + 1] = y ;
ikeys [4 * nikeys + 2] = s ;
ikeys [4 * nikeys + 3] = th ;
++ nikeys ;
}
/* now order by scale */
qsort (ikeys, nikeys, 4 * sizeof(double), korder) ;
if (verbose) {
printf ("sift: read %d keypoints from '%s'\n", nikeys, ifr.name) ;
}
/* close file */
vl_file_meta_close (&ifr) ;
}
/* ...............................................................
* Open output files
* ............................................................ */
err = vl_file_meta_open (&out, basename, "wb") ; WERR(out.name, writing) ;
err = vl_file_meta_open (&dsc, basename, "wb") ; WERR(dsc.name, writing) ;
err = vl_file_meta_open (&frm, basename, "wb") ; WERR(frm.name, writing) ;
err = vl_file_meta_open (&met, basename, "wb") ; WERR(met.name, writing) ;
if (verbose > 1) {
if (out.active) printf("sift: writing all ....... to . '%s'\n", out.name);
if (frm.active) printf("sift: writing frames .... to . '%s'\n", frm.name);
if (dsc.active) printf("sift: writing descriptors to . '%s'\n", dsc.name);
if (met.active) printf("sift: writign meta ...... to . '%s'\n", met.name);
}
/* ...............................................................
* Make filter
* ............................................................ */
filt = vl_sift_new (pim.width, pim.height, O, S, omin) ;
if (edge_thresh >= 0) vl_sift_set_edge_thresh (filt, edge_thresh) ;
if (peak_thresh >= 0) vl_sift_set_peak_thresh (filt, peak_thresh) ;
if (magnif >= 0) vl_sift_set_magnif (filt, magnif) ;
if (!filt) {
snprintf (err_msg, sizeof(err_msg),
"Could not create SIFT filter.") ;
err = VL_ERR_ALLOC ;
goto done ;
}
if (verbose > 1) {
printf ("sift: filter settings:\n") ;
printf ("sift: octaves (O) = %d\n",
vl_sift_get_noctaves (filt)) ;
printf ("sift: levels (S) = %d\n",
vl_sift_get_nlevels (filt)) ;
printf ("sift: first octave (o_min) = %d\n",
vl_sift_get_octave_first (filt)) ;
printf ("sift: edge thresh = %g\n",
vl_sift_get_edge_thresh (filt)) ;
printf ("sift: peak thresh = %g\n",
vl_sift_get_peak_thresh (filt)) ;
printf ("sift: magnif = %g\n",
vl_sift_get_magnif (filt)) ;
printf ("sift: will source frames? %s\n",
ikeys ? "yes" : "no") ;
printf ("sift: will force orientations? %s\n",
force_orientations ? "yes" : "no") ;
}
/* ...............................................................
* Process each octave
* ............................................................ */
i = 0 ;
first = 1 ;
while (1) {
VlSiftKeypoint const *keys ;
int nkeys ;
/* calculate the GSS for the next octave .................... */
if (first) {
first = 0 ;
err = vl_sift_process_first_octave (filt, fdata) ;
} else {
err = vl_sift_process_next_octave (filt) ;
}
if (err) {
err = VL_ERR_OK ;
break ;
}
if (verbose > 1) {
printf("sift: GSS octave %d computed\n",
vl_sift_get_octave_index (filt));
}
/* optionally save GSS */
if (gss.active) {
err = save_gss (filt, &gss, basename, verbose) ;
if (err) {
snprintf (err_msg, sizeof(err_msg),
"Could not write GSS to PGM file.") ;
goto done ;
}
}
/* run detector ............................................. */
if (ikeys == 0) {
vl_sift_detect (filt) ;
keys = vl_sift_get_keypoints (filt) ;
nkeys = vl_sift_get_nkeypoints (filt) ;
i = 0 ;
if (verbose > 1) {
printf ("sift: detected %d (unoriented) keypoints\n", nkeys) ;
}
} else {
nkeys = nikeys ;
}
/* for each keypoint ........................................ */
for (; i < nkeys ; ++i) {
double angles [4] ;
int nangles ;
VlSiftKeypoint ik ;
VlSiftKeypoint const *k ;
/* obtain keypoint orientations ........................... */
if (ikeys) {
vl_sift_keypoint_init (filt, &ik,
ikeys [4 * i + 0],
ikeys [4 * i + 1],
ikeys [4 * i + 2]) ;
if (ik.o != vl_sift_get_octave_index (filt)) {
break ;
}
k = &ik ;
/* optionally compute orientations too */
if (force_orientations) {
nangles = vl_sift_calc_keypoint_orientations
(filt, angles, k) ;
} else {
angles [0] = ikeys [4 * i + 3] ;
nangles = 1 ;
}
} else {
k = keys + i ;
nangles = vl_sift_calc_keypoint_orientations
(filt, angles, k) ;
}
/* for each orientation ................................... */
for (q = 0 ; q < nangles ; ++q) {
vl_sift_pix descr [128] ;
/* compute descriptor (if necessary) */
if (out.active || dsc.active) {
vl_sift_calc_keypoint_descriptor
(filt, descr, k, angles [q]) ;
}
if (out.active) {
int l ;
vl_file_meta_put_double (&out, k -> x ) ;
vl_file_meta_put_double (&out, k -> y ) ;
vl_file_meta_put_double (&out, k -> sigma ) ;
vl_file_meta_put_double (&out, angles [q] ) ;
for (l = 0 ; l < 128 ; ++l) {
vl_file_meta_put_uint8 (&out, (vl_uint8) (512.0 * descr [l])) ;
}
if (out.protocol == VL_PROT_ASCII) fprintf(out.file, "\n") ;
}
if (frm.active) {
vl_file_meta_put_double (&frm, k -> x ) ;
vl_file_meta_put_double (&frm, k -> y ) ;
vl_file_meta_put_double (&frm, k -> sigma ) ;
vl_file_meta_put_double (&frm, angles [q] ) ;
if (frm.protocol == VL_PROT_ASCII) fprintf(frm.file, "\n") ;
}
if (dsc.active) {
int l ;
for (l = 0 ; l < 128 ; ++l) {
double x = 512.0 * descr[l] ;
x = (x < 255.0) ? x : 255.0 ;
vl_file_meta_put_uint8 (&dsc, (vl_uint8) (x)) ;
}
if (dsc.protocol == VL_PROT_ASCII) fprintf(dsc.file, "\n") ;
}
}
}
}
/* ...............................................................
* Finish up
* ............................................................ */
if (met.active) {
fprintf(met.file, "<sift\n") ;
fprintf(met.file, " input = '%s'\n", name) ;
if (dsc.active) {
fprintf(met.file, " descriptors = '%s'\n", dsc.name) ;
}
if (frm.active) {
fprintf(met.file," frames = '%s'\n", frm.name) ;
}
fprintf(met.file, ">\n") ;
}
done :
/* release input keys buffer */
if (ikeys) {
free (ikeys) ;
ikeys_size = nikeys = 0 ;
ikeys = 0 ;
}
/* release filter */
if (filt) {
vl_sift_delete (filt) ;
filt = 0 ;
}
/* release image data */
if (fdata) {
free (fdata) ;
fdata = 0 ;
}
/* release image data */
if (data) {
free (data) ;
data = 0 ;
}
/* close files */
if (in) {
fclose (in) ;
in = 0 ;
}
vl_file_meta_close (&out) ;
vl_file_meta_close (&frm) ;
vl_file_meta_close (&dsc) ;
vl_file_meta_close (&met) ;
vl_file_meta_close (&gss) ;
vl_file_meta_close (&ifr) ;
/* if bad print error message */
if (err) {
fprintf
(stderr,
"sift: err: %s (%d)\n",
err_msg,
err) ;
exit_code = 1 ;
}
}
/* quit */
return exit_code ;
}
void sift_keypoints_and_descriptors(
float *pixels,
int width,
int height,
int max_descriptors,
int* nkeypoints, //output
int** keypoints, //output
int* ndescriptors, //output
float** descriptors) //output
{
unsigned int seed = time(NULL);
*keypoints = (int*) malloc(KEYPOINT_SPACE_SIZE * 2 * sizeof(int));
*descriptors = (float*) malloc(KEYPOINT_SPACE_SIZE * KEYPOINT_DESCRIPTOR_SIZE * sizeof(float));
//printf("width=%d height=%d\n", width, height);
//init the sift filter object
VlSiftFilt *filter = vl_sift_new(
width,//image width
height,//image height
-1,//number of octaves (-1 means all octaves)
3,//number of levels per octave
0);//startoctave (first is 0)
vl_sift_set_edge_thresh(filter, 10.0); //default: 10.0
vl_sift_set_peak_thresh(filter, 0.0); //default: 0.0
//printf("a\n");
//we start with the first octave first octave (highest image resolution)
vl_sift_process_first_octave(filter, pixels);
int keypoint_count = 0;
int descriptor_count = 0;
do
{
//detect the keypoints of the image
vl_sift_detect(filter);
//and get them
const VlSiftKeypoint* vlkeypoints = vl_sift_get_keypoints(filter);
//iterate them
int i;
for(i=0; i<filter->nkeys; i++)
{
//save keypoint coordinates
(*keypoints)[2*keypoint_count] = (int) vlkeypoints[i].x;
(*keypoints)[2*keypoint_count+1] = (int) vlkeypoints[i].y;
//calculate keypoint orientations
double angles[4];
int norients = vl_sift_calc_keypoint_orientations(
filter, angles, vlkeypoints+i);
//iterate orientations
int j;
for(j=0; j<norients; j++)
{
//calculate the descriptor
vl_sift_calc_keypoint_descriptor(
filter,
(*descriptors)+KEYPOINT_DESCRIPTOR_SIZE*descriptor_count,
vlkeypoints+i,
angles[j]);
descriptor_count++;
}
keypoint_count++;
}
}
//iterate over the rest of the octaves
while(vl_sift_process_next_octave(filter) != VL_ERR_EOF);
//printf("b\n");
//delete the filter object from memory
vl_sift_delete(filter);
//printf("c\n");
*keypoints = (int*) realloc(*keypoints, keypoint_count * 2 * sizeof(int));
*descriptors = (float*) realloc(*descriptors, descriptor_count * KEYPOINT_DESCRIPTOR_SIZE * sizeof(float));
//shuffle the keypoints and descriptors
int i;
for(i=0; i<descriptor_count; i++)
{
int r = rand_r(&seed) % descriptor_count;
int j;
for(j=0; j<KEYPOINT_DESCRIPTOR_SIZE; j++)
{
float tmp;
tmp = (*descriptors)[i*KEYPOINT_DESCRIPTOR_SIZE+j];
(*descriptors)[i*KEYPOINT_DESCRIPTOR_SIZE+j] = (*descriptors)[r*KEYPOINT_DESCRIPTOR_SIZE+j];
(*descriptors)[r*KEYPOINT_DESCRIPTOR_SIZE+j] = tmp;
}
}
//printf("descriptor_count=%d\n", descriptor_count);
*ndescriptors = (descriptor_count < max_descriptors) ? descriptor_count : max_descriptors;
*descriptors = (float*) realloc(*descriptors, (*ndescriptors) * KEYPOINT_DESCRIPTOR_SIZE * sizeof(float));
*nkeypoints = keypoint_count;
}
bool VlSIFTFeature::vl_keypoint_extractor(const vil_image_view<vxl_byte> & image,
const vl_feat_sift_parameter ¶m,
vcl_vector<bapl_keypoint_sptr> & keypoints,
bool verbose)
{
vil_image_view<vxl_byte> grey;
if (image.nplanes() == 1) {
grey.deep_copy(image);
}
else
{
vil_convert_planes_to_grey(image, grey);
}
int width = grey.ni();
int height = grey.nj();
int noctaves = param.noctaves; // maximum octatve possible
int nlevels = 3;
int o_min = 0; //first octave index
// create a filter to process the image
VlSiftFilt *filt = vl_sift_new (width, height, noctaves, nlevels, o_min) ;
double edge_thresh = param.edge_thresh;
double peak_thresh = param.peak_thresh;
double magnif = param.magnif ;
double norm_thresh = param.norm_thresh;
double window_size = param.window_size;
if (peak_thresh >= 0) vl_sift_set_peak_thresh (filt, peak_thresh) ;
if (edge_thresh >= 0) vl_sift_set_edge_thresh (filt, edge_thresh) ;
if (norm_thresh >= 0) vl_sift_set_norm_thresh (filt, norm_thresh) ;
if (magnif >= 0) vl_sift_set_magnif (filt, magnif) ;
if (window_size >= 0) vl_sift_set_window_size (filt, window_size) ;
// data from image
vl_sift_pix *fdata = (vl_sift_pix *)malloc(width * height * sizeof (vl_sift_pix));
for (int y = 0; y<grey.nj(); y++) {
for (int x = 0; x<grey.ni(); x++) {
int idx = y * width + x;
fdata[idx] = grey(x, y, 0);
}
}
// Process each octave
bool isFirst = true ;
vl_bool err = VL_ERR_OK;
int nangles = 0;
double angles[4];
vnl_vector_fixed<float, 128> descriptor;
while (1) {
if (isFirst) {
isFirst = false;
err = vl_sift_process_first_octave (filt, fdata) ;
} else {
err = vl_sift_process_next_octave (filt) ;
}
if(err == VL_ERR_EOF)
{
break;
}
vl_sift_detect (filt);
VlSiftKeypoint const * keys = vl_sift_get_keypoints(filt) ;
int nkeys = vl_sift_get_nkeypoints (filt) ;
for (int i = 0; i<nkeys; i++) {
VlSiftKeypoint const * curKey = keys + i;
// Depending on the symmetry of the keypoint appearance, determining the orientation can be ambiguous. SIFT detectors have up to four possible orientations
nangles = vl_sift_calc_keypoint_orientations(filt, angles, curKey) ;
for (int q = 0 ; q < nangles ; q++) {
vl_sift_calc_keypoint_descriptor(filt, &descriptor[0], curKey, angles[q]);
bapl_lowe_keypoint *pKeypoint = new bapl_lowe_keypoint();
double x = curKey->x;
double y = curKey->y;
double s = curKey->sigma;
double o = angles[q];
vnl_vector_fixed<double, 128> des;
for (int j = 0; j<128; j++) {
des[j] = descriptor[j];
}
pKeypoint->set_location_i(x);
pKeypoint->set_location_j(y);
pKeypoint->set_scale(s);
pKeypoint->set_orientation(o);
pKeypoint->set_descriptor(des);
keypoints.push_back(bapl_keypoint_sptr(pKeypoint));
}
}
}
vl_sift_delete(filt);
delete fdata;
if(verbose){
vcl_cout<<"Found "<<keypoints.size()<<" keypoints."<<vcl_endl;
}
return true;
}
int main (int argc, const char * argv[]) {
int w=1280,h=720;
int i=0;
int nkeypoints=0;
int press=0;
char img2_file[] = "/Users/quake0day/ana2/MVI_0124_QT 768Kbps_012.mov";
vl_bool render=1;
vl_bool first=1;
VlSiftFilt * myFilter=0;
VlSiftKeypoint const* keys;
//CvCapture * camera = cvCreateCameraCapture (CV_CAP_ANY);
CvCapture * camera = cvCreateFileCapture(img2_file);
vl_sift_pix *descriptorsA, *descriptorsB;
int ndescA=0, ndescB=0;
//DescriptorA file
int dscfd;
struct stat filestat;
dscfd = open("/Users/quake0day/ana2/saveC.jpg.dsc", O_RDONLY, 0644);
fstat(dscfd, &filestat);
int filesize=filestat.st_size;
descriptorsA=(vl_sift_pix*)mmap(0, filesize, PROT_READ, MAP_SHARED, dscfd, 0);
ndescA=(filesize/sizeof(vl_sift_pix))/DESCSIZE;
printf("number of descriptors: %d\n", ndescA);
//Build kdtreeA
VlKDForest *myforest=vl_kdforest_new(VL_TYPE_FLOAT, DESCSIZE, 1);
vl_kdforest_build(myforest, ndescA, descriptorsA);
//DescriptorsB file
dscfd=open("/Users/quake0day/ana2/saveD.jpg.dsc", O_RDONLY, 0644);
fstat(dscfd, &filestat);
filesize=filestat.st_size;
descriptorsB=(vl_sift_pix*)mmap(0, filesize, PROT_READ, MAP_SHARED, dscfd, 0);
ndescB=(filesize/sizeof(vl_sift_pix))/DESCSIZE;
printf("number of descriptors: %d\n", ndescB);
//Build kdtreeB
VlKDForest *myforestB=vl_kdforest_new(VL_TYPE_FLOAT, DESCSIZE, 1);
vl_kdforest_build(myforestB, ndescB, descriptorsB);
//Neighbors
VlKDForestNeighbor *neighbors=(VlKDForestNeighbor*)malloc(sizeof(VlKDForestNeighbor));
VlKDForestNeighbor *neighborsB=(VlKDForestNeighbor*)malloc(sizeof(VlKDForestNeighbor));
//Image variables
vl_sift_pix* fim;
int err=0;
int octave, nlevels, o_min;
cvNamedWindow("Hello", 1);
//For text
CvFont font;
double hScale=2;
double vScale=2;
int lineWidth=2;
cvInitFont(&font,CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, hScale,vScale,0,lineWidth, 1);
IplImage *myCVImage=cvQueryFrame(camera);//cvLoadImage("2.jpg", -1);
IplImage *afterCVImage=cvCreateImage(cvSize(w, h), IPL_DEPTH_8U, 1);
IplImage *resizingImg=cvCreateImage(cvSize(w, h), myCVImage->depth, myCVImage->nChannels);
octave=2;
nlevels=5;
o_min=1;
myFilter=vl_sift_new(w, h, octave, nlevels, o_min);
vl_sift_set_peak_thresh(myFilter, 0.5);
fim=malloc(sizeof(vl_sift_pix)*w*h);
float thre;
while (myCVImage) {
dprintf("%d*%d\n",myCVImage->width,myCVImage->height);
cvResize(myCVImage, resizingImg, CV_INTER_AREA);
dprintf("resized scale:%d*%d\n",myCVImage->width,myCVImage->height);
if (press=='s') {
cvSaveImage("save.jpg", resizingImg);
}
cvConvertImage(resizingImg, afterCVImage, 0);
for (i=0; i<h; i++) {
for (int j=0; j<w; j++) {
fim[i*w+j]=CV_IMAGE_ELEM(afterCVImage,uchar,i,j);
}
}
//vl_sift_set_peak_thresh(myFilter, 0.5);
//vl_sift_set_edge_thresh(myFilter, 10.0);
first=1;
while (1) {
printf("~~~~~~~~~~start of octave~~~~~~~~~~~~\n");
if (first) {
first=0;
thre=0.25;
err=vl_sift_process_first_octave(myFilter, fim);
}
else {
thre=0.05;
err=vl_sift_process_next_octave(myFilter);
}
if (err) {
err=VL_ERR_OK;
break;
}
printf("Octave: %d\n", vl_sift_get_octave_index(myFilter));
vl_sift_detect(myFilter);
nkeypoints=vl_sift_get_nkeypoints(myFilter);
dprintf("insider numkey:%d\n",nkeypoints);
keys=vl_sift_get_keypoints(myFilter);
dprintf("final numkey:%d\n",nkeypoints);
int countA=0, countB=0;
int matchcountA=0, matchcountB=0;
float avgA=0, avgB=0;
if (render) {
for (i=0; i<nkeypoints; i++) {
//cvCircle(resizingImg, cvPoint(keys->x, keys->y), keys->sigma, cvScalar(100, 255, 50, 0), 1, CV_AA, 0);
dprintf("x:%f,y:%f,s:%f,sigma:%f,\n",keys->x,keys->y,keys->s,keys->sigma);
double angles [4] ;
int nangles ;
/* obtain keypoint orientations ........................... */
nangles=vl_sift_calc_keypoint_orientations(myFilter, angles, keys);
/* for each orientation ................................... */
for (int q = 0 ; q < (unsigned) 1 ; ++q)
{
vl_sift_pix descr [128] ;
/* compute descriptor (if necessary) */
vl_sift_calc_keypoint_descriptor(myFilter, descr, keys, angles[q]);
for (int j=0; j<128; j++)
{
descr[j]*=512.0;
descr[j]=(descr[j]<255.0)?descr[j]:255.0;
}
vl_kdforest_query(myforest, neighbors, 1, descr);
vl_kdforest_query(myforestB, neighborsB, 1, descr);
if (neighbors->distance<50000.0)
{
matchcountA++;
cvCircle(resizingImg, cvPoint(keys->x, keys->y), keys->sigma, cvScalar(100, 0, 0, 255), 1, CV_AA, 0);
}
if (neighborsB->distance<50000.0)
{
matchcountB++;
cvCircle(resizingImg, cvPoint(keys->x, keys->y), keys->sigma, cvScalar(0, 50, 255, 100), 1, CV_AA, 0);
}
countA++;
avgA+=neighbors->distance;
countB++;
avgB+=neighborsB->distance;
}
keys++;
}
}
avgA=avgA/countA;
float percentage=((float)matchcountA*2)/ndescA;
printf("Percentage:%f\n", percentage);
printf("avg:%f\n",avgA);
printf("thre==%f\n", thre);
if (percentage>=thre) {
printf("A shows!!!\n");
cvPutText (resizingImg, "A shows!!",cvPoint(50, 100), &font, cvScalar(0,255,255,0));
}
avgB=avgB/countB;
percentage=((float)matchcountB*2.5)/ndescB;
printf("Percentage:%f\n", percentage);
printf("avg:%f\n",avgB);
printf("thre==%f\n", thre);
if (percentage>=thre) {
printf("B shows!!!\n");
cvPutText (resizingImg, "B shows!!",cvPoint(400, 100), &font, cvScalar(0,255,255,0));
}
printf("~~~~~~~~~~~end of octave~~~~~~~~~~~~\n");
}
cvShowImage("Hello", resizingImg);
myCVImage = cvQueryFrame(camera);
press=cvWaitKey(1);
if( press=='q' )
break;
else if( press=='r' )
render=1-render;
}
free(fim);
free(neighbors);
free(neighborsB);
cvReleaseImage(&afterCVImage);
cvReleaseImage(&resizingImg);
cvReleaseImage(&myCVImage);
return 0;
}
/**
@brief Detect regions on the image and compute their attributes (description)
@param image Image.
@param regions The detected regions and attributes (the caller must delete the allocated data)
@param mask 8-bit gray image for keypoint filtering (optional).
Non-zero values depict the region of interest.
*/
bool Describe(const image::Image<unsigned char>& image,
std::unique_ptr<Regions> ®ions,
const image::Image<unsigned char> * mask = NULL)
{
const int w = image.Width(), h = image.Height();
//Convert to float
const image::Image<float> If(image.GetMat().cast<float>());
VlSiftFilt *filt = vl_sift_new(w, h,
_params._num_octaves, _params._num_scales, _params._first_octave);
if (_params._edge_threshold >= 0)
vl_sift_set_edge_thresh(filt, _params._edge_threshold);
if (_params._peak_threshold >= 0)
vl_sift_set_peak_thresh(filt, 255*_params._peak_threshold/_params._num_scales);
Descriptor<vl_sift_pix, 128> descr;
Descriptor<unsigned char, 128> descriptor;
// Process SIFT computation
vl_sift_process_first_octave(filt, If.data());
Allocate(regions);
// Build alias to cached data
SIFT_Regions * regionsCasted = dynamic_cast<SIFT_Regions*>(regions.get());
// reserve some memory for faster keypoint saving
regionsCasted->Features().reserve(2000);
regionsCasted->Descriptors().reserve(2000);
while (true) {
vl_sift_detect(filt);
VlSiftKeypoint const *keys = vl_sift_get_keypoints(filt);
const int nkeys = vl_sift_get_nkeypoints(filt);
// Update gradient before launching parallel extraction
vl_sift_update_gradient(filt);
#ifdef OPENMVG_USE_OPENMP
#pragma omp parallel for private(descr, descriptor)
#endif
for (int i = 0; i < nkeys; ++i) {
// Feature masking
if (mask)
{
const image::Image<unsigned char> & maskIma = *mask;
if (maskIma(keys[i].y, keys[i].x) == 0)
continue;
}
double angles [4] = {0.0, 0.0, 0.0, 0.0};
int nangles = 1; // by default (1 upright feature)
if (_bOrientation)
{ // compute from 1 to 4 orientations
nangles = vl_sift_calc_keypoint_orientations(filt, angles, keys+i);
}
for (int q=0 ; q < nangles ; ++q) {
vl_sift_calc_keypoint_descriptor(filt, &descr[0], keys+i, angles[q]);
const SIOPointFeature fp(keys[i].x, keys[i].y,
keys[i].sigma, static_cast<float>(angles[q]));
siftDescToUChar(&descr[0], descriptor, _params._root_sift);
#ifdef OPENMVG_USE_OPENMP
#pragma omp critical
#endif
{
regionsCasted->Descriptors().push_back(descriptor);
regionsCasted->Features().push_back(fp);
}
}
}
if (vl_sift_process_next_octave(filt))
break; // Last octave
}
vl_sift_delete(filt);
return true;
};
int main (int argc, const char * argv[]) {
char *imagefilename=(char*)malloc(sizeof(char)*16);
char *dscfilename=(char*)malloc(sizeof(char)*16);
if (argc<3) {
printf("Usage: ./dump-descr image-file-name descriptor-file-name");
strcpy(imagefilename, "savekkkk.jpg");
strcpy(dscfilename, "saveD.jpg.dsc");
}
else {
strcpy(imagefilename,argv[1]);
strcpy(dscfilename,argv[2]);
}
FILE* dscfile;
int w=1280,h=720;
int i=0;
int nkeypoints=0;
vl_bool render=1;
vl_bool first=1;
VlSiftFilt * myFilter=0;
VlSiftKeypoint const* keys;
char img2_file[] = "/Users/quake0day/ana2/MVI_0124.MOV";
//printf("sizeof(VlSiftKeypoint)=%d, filt=%d, pix=%d\n", sizeof(VlSiftKeypoint), sizeof(VlSiftFilt),sizeof(vl_sift_pix));
dscfile=fopen(dscfilename, "wb");
vl_sift_pix* fim;
int err=0;
int octave, nlevels, o_min;
//vl_sift_pix descr[128];
//CvCapture * camera = cvCreateCameraCapture (CV_CAP_ANY);
CvCapture * camera = cvCreateFileCapture(img2_file);
cvNamedWindow("Hello", 1);
IplImage *myCVImage=cvQueryFrame(camera);//cvLoadImage(imagefilename, 0);
IplImage *afterCVImage=cvCreateImage(cvSize(w, h), IPL_DEPTH_8U, 1);
IplImage *resizingImg=cvCreateImage(cvSize(w, h), myCVImage->depth, myCVImage->nChannels);
octave=3;
nlevels=10;
o_min=1;
myFilter=vl_sift_new(w, h, octave, nlevels, o_min);
vl_sift_set_peak_thresh(myFilter, 0.5);
fim=malloc(sizeof(vl_sift_pix)*w*h);
int press=0;
while (myCVImage) {
dprintf("%d*%d\n",myCVImage->width,myCVImage->height);
//w=myCVImage->width;
//h=myCVImage->height;
cvResize(myCVImage, resizingImg, CV_INTER_AREA);
dprintf("resized scale:%d*%d\n",myCVImage->width,myCVImage->height);
cvConvertImage(resizingImg, afterCVImage, 0);
for (i=0; i<h; i++) {
for (int j=0; j<w; j++) {
fim[i*w+j]=CV_IMAGE_ELEM(afterCVImage,uchar,i,j);
//printf("%f ", fim[i*w+j]);
}
}
//vl_sift_set_peak_thresh(myFilter, 0.5);
//vl_sift_set_edge_thresh(myFilter, 10.0);
first=1;
while (1) {
if (first) {
first=0;
err=vl_sift_process_first_octave(myFilter, fim);
}
else {
err=vl_sift_process_next_octave(myFilter);
}
if (err) {
err=VL_ERR_OK;
break;
}
vl_sift_detect(myFilter);
nkeypoints=vl_sift_get_nkeypoints(myFilter);
dprintf("insider numkey:%d\n",nkeypoints);
keys=vl_sift_get_keypoints(myFilter);
dprintf("final numkey:%d\n",nkeypoints);
if (render) {
for (i=0; i<nkeypoints; i++) {
cvCircle(resizingImg, cvPoint(keys->x, keys->y), keys->sigma, cvScalar(100, 255, 50, 0), 1, CV_AA, 0);
//printf("x:%f,y:%f,s:%f,sigma:%f,\n",keys->x,keys->y,keys->s,keys->sigma);
if (press=='d') {
double angles [4] ;
int nangles ;
/* obtain keypoint orientations ........................... */
nangles=vl_sift_calc_keypoint_orientations(myFilter, angles, keys);
/* for each orientation ................................... */
for (int q = 0 ; q < (unsigned) nangles ; ++q) {
vl_sift_pix descr [128] ;
//printf("\n");
/* compute descriptor (if necessary) */
vl_sift_calc_keypoint_descriptor(myFilter, descr, keys, angles[q]);
for (int j=0; j<128; j++) {
descr[j]*=512.0;
descr[j]=(descr[j]<255.0)?descr[j]:255.0;
printf("%f ", descr[j]);
}
fwrite(descr, sizeof(vl_sift_pix), 128, dscfile);
}
}
keys++;
}
}
}
cvShowImage("Hello", resizingImg);
myCVImage = cvQueryFrame(camera);
press=cvWaitKey(1);
if( press=='q' )
return 0;
else if( press=='r' )
render=1-render;
}
free(fim);
cvReleaseImage(&afterCVImage);
cvReleaseImage(&resizingImg);
cvReleaseImage(&myCVImage);
return 0;
}
void SIFT_ADAPTER::extractSiftFeature()
{
check_image();
if (m_has_extracted)
return;
set_gray_image_data();
set_sift_model();
m_num_frames = 0;
bool bfirst = true;
while (true) // for each octave
{
int err = 0;
if (bfirst)
{
err = vl_sift_process_first_octave(m_sift_model, m_gray_data);
bfirst = false;
}
else
err = vl_sift_process_next_octave(m_sift_model);
if (err)
break;
vl_sift_detect(m_sift_model);
const int cur_num_key_pts = vl_sift_get_nkeypoints(m_sift_model);
const VlSiftKeypoint* cur_key_pts = vl_sift_get_keypoints(
m_sift_model);
//std::cout << "detected " << cur_num_key_pts << std::endl;
for (int i = 0; i < cur_num_key_pts; ++i)
{
const VlSiftKeypoint* cur_keypt = cur_key_pts + i;
double angles[4];
int nangle = vl_sift_calc_keypoint_orientations(m_sift_model,
angles,
cur_keypt);
for (int q = 0; q < nangle; ++q)
{
float cur_desc[DEFAULT_SIFT_DIM];
memset(cur_desc, 0, DEFAULT_SIFT_DIM * sizeof(float));
vl_sift_calc_keypoint_descriptor(m_sift_model, cur_desc,
cur_keypt, angles[q]);
SIFT_Frame cur_frame;
cur_frame.x = cur_keypt->x;
cur_frame.y = cur_keypt->y;
cur_frame.scale = cur_keypt->sigma;
cur_frame.angle = angles[q];
copy(cur_desc, cur_desc + DEFAULT_SIFT_DIM,
cur_frame.descriptor.begin());
m_frames.push_back(cur_frame);
++m_num_frames;
}
}
}
m_has_extracted = true;
}
int GetSiftFeatures(unsigned char *data, int nw, int nh, float *features, int *features_num)
{
vl_sift_pix *img_data = (vl_sift_pix *)malloc(sizeof(vl_sift_pix) * nw * nh);
if(img_data == NULL)
{
printf("Memory overflow error:can't apply image data memory!\n");
return -1;
}
unsigned char *pixel;
int i = 0, j = 0;
for(i = 0;i < nh;++i)
{
for(j = 0;j < nw;++j)
{
pixel = (unsigned char *)(data + i * nw + j);
img_data[i * nw + j] = *pixel;
}
}
int noctaves = 4, nlevels = 3, o_min = -1;
VlSiftFilt *sift_filt = NULL;
sift_filt = vl_sift_new(nw, nh, noctaves, nlevels, o_min);
int num_descriptors = 0;
// int save_flag = -1;
if(vl_sift_process_first_octave(sift_filt,img_data) != VL_ERR_EOF)
{
while(1)
{
vl_sift_detect(sift_filt);
VlSiftKeypoint *sift_keypoints = sift_filt->keys;
for(i = 0; i < sift_filt->nkeys;++i)
{
VlSiftKeypoint temp_sift_keypoint = *sift_keypoints;
double angles[4];
int angle_count = vl_sift_calc_keypoint_orientations(sift_filt,angles,&temp_sift_keypoint);
for(j = 0; j < angle_count;++j)
{
double temp_angle = angles[j];
float *descriptor = (float *)malloc(sizeof(float) * SIFT_DESCRIPTOR_DIM);
vl_sift_calc_keypoint_descriptor(sift_filt, descriptor, &temp_sift_keypoint, temp_angle);
float *curr_features = features + num_descriptors * SIFT_DESCRIPTOR_DIM;
// if(save_flag == -1)
// {
memcpy(curr_features,descriptor,sizeof(float) * SIFT_DESCRIPTOR_DIM);
//save_flag == 1;
// }
++num_descriptors;
free(descriptor);
}
++sift_keypoints;
}
if(vl_sift_process_next_octave(sift_filt) == VL_ERR_EOF)
{
break;
}
}
}
*features_num = num_descriptors;
vl_sift_delete(sift_filt);
free(img_data);
return 0;
}
