bool VLFeat::Initialize_kmeans() {
bin_data dat(kmeansname);
kmeans = vl_kmeans_new(VL_TYPE_FLOAT, VlDistanceL2);
vl_kmeans_set_centers(kmeans, dat.vector_address(0),
dat.vdim(), dat.nobjects());
if (MethodVerbose())
cout << "VLFeat::Initialize_kmeans() read in kmeans <" << kmeansname
<< "> dim=" << descriptor_dim() << " nclust=" << nclusters()
<< endl;
if (kdtree_ntrees) {
kdtree = vl_kdforest_new(VL_TYPE_FLOAT, descriptor_dim(), kdtree_ntrees,
VlDistanceL2);
vl_kdforest_build(kdtree, nclusters(), means());
vl_kdforest_set_max_num_comparisons(kdtree, kdtree_maxcomps);
}
do_vlad = true;
return true;
}
void kkdforest_new(float* data, int length, int dim, int nbtrees)
{
forest = vl_kdforest_new(
dim, //dimension of data
nbtrees);
vl_kdforest_build(forest, length, data);
}
//void xcorr(float *tr1, float *tr2, double *corp, long long shift,
void knn (float *buffer_delayembedding_selec, float * density_vals , vl_size len_array, int num_neighbours)
{
VL_PRINT ("KNN search !") ;
printf("size of each frame = %llu\n", len_array);
// instantiate a KD TREE object
// VlKDForest returns new KDForest.
// The data dimension dimension and the number of trees numTrees must not be smaller than one.
VlKDForest* kdtree_obj;
// define params for the object
kdtree_obj = vl_kdforest_new(VL_TYPE_FLOAT, 3, 1, VlDistanceL2);
// populate it with the data to be subsampled
vl_kdforest_build (kdtree_obj,len_array,buffer_delayembedding_selec);
// instantiate a searcher object for querying knn
// A searcher is an object attached to the forest which must be created before running the queries. Each query has to be invoked with the searcher as its argument; make it point to the declared and defined kdtree
VlKDForestSearcher* kdforest_search_obj=vl_kdforest_new_searcher(kdtree_obj);
VlKDForestNeighbor neighbours[num_neighbours+1];
float *query = malloc(3*sizeof(float));
/* for (int i=0; i<len_array; i++)
{
printf("% d th original :%f %f %f\n",i, buffer_delayembedding_selec [3*i],buffer_delayembedding_selec [3*i+1],buffer_delayembedding_selec [3*i+2]);
} */
for (int i=0; i<len_array; i++)
{
// printf("DBG: buffer selec[%d] :%f %f %f\n",i, buffer_delayembedding_selec [3*i],buffer_delayembedding_selec [3*i+1],buffer_delayembedding_selec [3*i+2]);
get_query(buffer_delayembedding_selec , query , i);
int nvisited = vl_kdforestsearcher_query(kdforest_search_obj, &neighbours[0], num_neighbours+1, query);
// printf("visited nodes = %d ", nvisited);
// printf("for knn of %dth node : (%f,%f,%f) :", i,*query,*(query+1),*(query+2));
density_vals[i]=1/sqrtf(neighbours[num_neighbours].distance);
// printf("DB %f \n",( density_vals[i]));
}
// Destroy all created instances
vl_kdforest_delete ( kdtree_obj );
free(query);
}
VlKDForest *
kdtreebuild(int verbose,
vl_size dimension,
vl_size numTrees,
int thresholdingMethod,
vl_size numData, float *data)
{
vl_type dataType = VL_TYPE_FLOAT;
VlKDForest * forest;
forest = vl_kdforest_new (dataType, dimension, numTrees) ;
vl_kdforest_set_thresholding_method (forest, thresholdingMethod) ;
if (verbose) {
char const * str = 0 ;
printf("vl_kdforestbuild: data %s [%d x %d]\n",
vl_get_type_name (dataType), dimension, numData) ;
switch (vl_kdforest_get_thresholding_method(forest)) {
case VL_KDTREE_MEAN : str = "mean" ; break ;
case VL_KDTREE_MEDIAN : str = "median" ; break ;
default: abort() ;
}
printf("vl_kdforestbuild: threshold selection method: %s\n", str) ;
printf("vl_kdforestbuild: number of trees: %d\n",
vl_kdforest_get_num_trees(forest)) ;
}
/* -----------------------------------------------------------------
* Do job
* -------------------------------------------------------------- */
vl_kdforest_build (forest, numData, data) ;
if (verbose) {
vl_uindex ti ;
for (ti = 0 ; ti < vl_kdforest_get_num_trees(forest) ; ++ ti) {
printf("vl_kdforestbuild: tree %d: depth %d, num nodes %d\n",
ti,
vl_kdforest_get_depth_of_tree(forest, ti),
vl_kdforest_get_num_nodes_of_tree(forest, ti)) ;
}
}
return(forest);
}
void LLC::SetUp()
{
if (base_.get() == NULL || dim_ == 0 || num_base_ == 0)
{
cerr << "ERROR: must set the base before." << endl;
exit(-1);
}
if (kdforest_model_ != NULL)
vl_kdforest_delete(kdforest_model_);
kdforest_model_ = vl_kdforest_new(VL_TYPE_FLOAT, dim_, num_tree_,
dist_method_);
vl_kdforest_set_thresholding_method(kdforest_model_, thrd_method_);
vl_kdforest_set_max_num_comparisons(kdforest_model_, max_comp_);
vl_kdforest_build(kdforest_model_, num_base_, base_.get());
has_setup_ = true;
}
void
mexFunction(int nout, mxArray *out[],
int nin, const mxArray *in[])
{
enum {IN_DATA = 0, IN_END} ;
enum {OUT_TREE = 0} ;
int verbose = 0 ;
int opt ;
int next = IN_END ;
mxArray const *optarg ;
VlKDForest * forest ;
void * data ;
vl_size numData ;
vl_size dimension ;
mxClassID dataClass ;
vl_type dataType ;
int thresholdingMethod = VL_KDTREE_MEDIAN ;
vl_size numTrees = 1 ;
VL_USE_MATLAB_ENV ;
/* -----------------------------------------------------------------
* Check the arguments
* -------------------------------------------------------------- */
if (nin < 1) {
vlmxError(vlmxErrInvalidArgument,
"At least one argument required") ;
} else if (nout > 2) {
vlmxError(vlmxErrInvalidArgument,
"Too many output arguments");
}
dataClass = mxGetClassID(IN(DATA)) ;
if (! vlmxIsMatrix (IN(DATA), -1, -1) ||
! vlmxIsReal (IN(DATA))) {
vlmxError(vlmxErrInvalidArgument,
"DATA must be a real matrix ") ;
}
switch (dataClass) {
case mxSINGLE_CLASS : dataType = VL_TYPE_FLOAT ; break ;
case mxDOUBLE_CLASS : dataType = VL_TYPE_DOUBLE ; break ;
default:
vlmxError(vlmxErrInvalidArgument,
"DATA must be either SINGLE or DOUBLE") ;
}
while ((opt = vlmxNextOption (in, nin, options, &next, &optarg)) >= 0) {
char buffer [1024] ;
switch (opt) {
case opt_threshold_method :
mxGetString (optarg, buffer, sizeof(buffer)/sizeof(buffer[0])) ;
if (! vlmxIsString(optarg, -1)) {
vlmxError(vlmxErrInvalidOption,
"THRESHOLDMETHOD must be a string") ;
}
if (vl_string_casei_cmp(buffer, "median") == 0) {
thresholdingMethod = VL_KDTREE_MEDIAN ;
} else if (vl_string_casei_cmp(buffer, "mean") == 0) {
thresholdingMethod = VL_KDTREE_MEAN ;
} else {
vlmxError(vlmxErrInvalidOption,
"Unknown thresholding method %s", buffer) ;
}
break ;
case opt_num_trees :
if (! vlmxIsScalar(optarg) ||
(numTrees = mxGetScalar(optarg)) < 1) {
vlmxError(vlmxErrInvalidOption,
"NUMTREES must be not smaller than one") ;
}
break ;
case opt_verbose :
++ verbose ;
break ;
}
}
data = mxGetData (IN(DATA)) ;
numData = mxGetN (IN(DATA)) ;
dimension = mxGetM (IN(DATA)) ;
forest = vl_kdforest_new (dataType, dimension, numTrees) ;
vl_kdforest_set_thresholding_method (forest, thresholdingMethod) ;
if (verbose) {
char const * str = 0 ;
mexPrintf("vl_kdforestbuild: data %s [%d x %d]\n",
vl_get_type_name (dataType), dimension, numData) ;
switch (vl_kdforest_get_thresholding_method(forest)) {
case VL_KDTREE_MEAN : str = "mean" ; break ;
case VL_KDTREE_MEDIAN : str = "median" ; break ;
default: abort() ;
}
mexPrintf("vl_kdforestbuild: threshold selection method: %s\n", str) ;
mexPrintf("vl_kdforestbuild: number of trees: %d\n",
vl_kdforest_get_num_trees(forest)) ;
}
/* -----------------------------------------------------------------
* Do job
* -------------------------------------------------------------- */
vl_kdforest_build (forest, numData, data) ;
if (verbose) {
vl_uindex ti ;
for (ti = 0 ; ti < vl_kdforest_get_num_trees(forest) ; ++ ti) {
mexPrintf("vl_kdforestbuild: tree %d: depth %d, num nodes %d\n",
ti,
vl_kdforest_get_depth_of_tree(forest, ti),
vl_kdforest_get_num_nodes_of_tree(forest, ti)) ;
}
}
out[OUT_TREE] = new_array_from_kdforest (forest) ;
vl_kdforest_delete (forest) ;
}
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;
}
