void
test_query_from_file(int verbose)
{
VlKDForest *forest;
int i;
float *data, *query;
vl_size dim;
vl_size num;
/*
* load
*/
data = load_data("data.bin", &dim, &num);
forest = load_VlKDForest("forest.bin");
forest->data = data;
if((query = (float *)malloc(dim * sizeof(float))) == NULL){
printf("not enough memoey\n");
exit(1);
}
for(i = 0;i < dim; i++) query[i] = 0.5;
if(verbose) printf("has created a query\n");
/*
* search neighbors
*/
vl_size numNeighbors = 10;
unsigned int numComparisons = 0 ;
unsigned int maxNumComparisons = 0 ;
VlKDForestNeighbor * neighbors ;
vl_kdforest_set_max_num_comparisons (forest, maxNumComparisons) ;
neighbors = vl_malloc (sizeof(VlKDForestNeighbor) * numNeighbors) ;
numComparisons = vl_kdforest_query (forest, neighbors, numNeighbors,
query);
for(i = 0;i < numNeighbors; i++){
printf("%d %f\n",
neighbors[i].index + 1, neighbors[i].distance);
/* check distance */
if(fabs(
dist_l2(dim, query, &data[neighbors[i].index * dim]) -
neighbors[i].distance) > 1e-6){
printf("%d distance is different. %f\n",
dist_l2(dim, query, &data[neighbors[i].index * dim]) );
}
/* check order */
if(i != 0 && neighbors[i-1].distance > neighbors[i].distance){
printf("order is wrong.\n");
}
}
vl_free(neighbors);
vl_kdforest_delete(forest);
free(data);
free(query);
}
void kkdforest_query(float* point, int num_neighbors, unsigned int* indexes, float* distances, int* num_visited)
{
if (forest == 0) {
printf("no forest\n");
return;
}
VlKDForestNeighbor* neighbors = malloc(sizeof(VlKDForestNeighbor) * num_neighbors);
*num_visited = vl_kdforest_query(
forest,
neighbors,
num_neighbors,
point);
int i;
for (i=0; i<num_neighbors; i++)
{
indexes[i] = neighbors[i].index;
distances[i] = neighbors[i].distance;
}
free(neighbors);
}
void
mexFunction(int nout, mxArray *out[],
int nin, const mxArray *in[])
{
enum {IN_FOREST = 0, IN_DATA, IN_QUERY, IN_END} ;
enum {OUT_INDEX = 0, OUT_DISTANCE} ;
int verbose = 0 ;
int opt ;
int next = IN_END ;
mxArray const *optarg ;
VlKDForest * forest ;
mxArray const * forest_array = in[IN_FOREST] ;
mxArray const * data_array = in[IN_DATA] ;
mxArray const * query_array = in[IN_QUERY] ;
mxArray * index_array ;
mxArray * distance_array ;
void * query ;
vl_uint32 * index ;
void * distance ;
vl_size numNeighbors = 1 ;
vl_size numQueries ;
vl_uindex qi, ni;
unsigned int numComparisons = 0 ;
unsigned int maxNumComparisons = 0 ;
VlKDForestNeighbor * neighbors ;
mxClassID dataClass ;
VL_USE_MATLAB_ENV ;
/* -----------------------------------------------------------------
* Check the arguments
* -------------------------------------------------------------- */
if (nin < 3) {
vlmxError(vlmxErrNotEnoughInputArguments, NULL) ;
}
if (nout > 2) {
vlmxError(vlmxErrTooManyOutputArguments, NULL) ;
}
forest = new_kdforest_from_array (forest_array, data_array) ;
dataClass = mxGetClassID (data_array) ;
if (mxGetClassID (query_array) != dataClass) {
vlmxError(vlmxErrInvalidArgument,
"QUERY must have the same storage class as DATA.") ;
}
if (! vlmxIsReal (query_array)) {
vlmxError(vlmxErrInvalidArgument,
"QUERY must be real.") ;
}
if (! vlmxIsMatrix (query_array, forest->dimension, -1)) {
vlmxError(vlmxErrInvalidArgument,
"QUERY must be a matrix with TREE.NUMDIMENSIONS rows.") ;
}
while ((opt = vlmxNextOption (in, nin, options, &next, &optarg)) >= 0) {
switch (opt) {
case opt_num_neighs :
if (! vlmxIsScalar(optarg) ||
(numNeighbors = mxGetScalar(optarg)) < 1) {
vlmxError(vlmxErrInvalidArgument,
"NUMNEIGHBORS must be a scalar not smaller than one.") ;
}
break;
case opt_max_num_comparisons :
if (! vlmxIsScalar(optarg)) {
vlmxError(vlmxErrInvalidArgument,
"MAXNUMCOMPARISONS must be a scalar.") ;
}
maxNumComparisons = mxGetScalar(optarg) ;
break;
case opt_verbose :
++ verbose ;
break ;
}
}
vl_kdforest_set_max_num_comparisons (forest, maxNumComparisons) ;
neighbors = vl_malloc (sizeof(VlKDForestNeighbor) * numNeighbors) ;
query = mxGetData (query_array) ;
numQueries = mxGetN (query_array) ;
out[OUT_INDEX] = index_array = mxCreateNumericMatrix
(numNeighbors, numQueries, mxUINT32_CLASS, mxREAL) ;
out[OUT_DISTANCE] = distance_array = mxCreateNumericMatrix
(numNeighbors, numQueries, dataClass, mxREAL) ;
index = mxGetData (index_array) ;
distance = mxGetData (distance_array) ;
if (verbose) {
VL_PRINTF ("vl_kdforestquery: number of queries: %d\n", numQueries) ;
VL_PRINTF ("vl_kdforestquery: number of neighbors per query: %d\n", numNeighbors) ;
VL_PRINTF ("vl_kdforestquery: max num of comparisons per query: %d\n",
vl_kdforest_get_max_num_comparisons (forest)) ;
}
for (qi = 0 ; qi < numQueries ; ++ qi) {
numComparisons += vl_kdforest_query (forest, neighbors, numNeighbors,
query) ;
switch (dataClass) {
case mxSINGLE_CLASS:
{
float * distance_ = (float*) distance ;
for (ni = 0 ; ni < numNeighbors ; ++ni) {
*index++ = neighbors[ni].index + 1 ;
*distance_++ = neighbors[ni].distance ;
}
query = (float*)query + vl_kdforest_get_data_dimension (forest) ;
distance = distance_ ;
break ;
}
case mxDOUBLE_CLASS:
{
double * distance_ = (double*) distance ;
for (ni = 0 ; ni < numNeighbors ; ++ni) {
*index++ = neighbors[ni].index + 1 ;
*distance_++ = neighbors[ni].distance ;
}
query = (double*)query + vl_kdforest_get_data_dimension (forest) ;
distance = distance_ ;
break ;
}
default:
abort() ;
}
}
if (verbose) {
VL_PRINTF ("vl_kdforestquery: number of comparisons per query: %.3f\n",
((double) numComparisons) / numQueries) ;
VL_PRINTF ("vl_kdforestquery: number of comparisons per neighbor: %.3f\n",
((double) numComparisons) / (numQueries * numNeighbors)) ;
}
vl_kdforest_delete (forest) ;
vl_free (neighbors) ;
}
void
test_simple(int verbose)
{
VlKDForest *forest;
int i, j;
float *data, *query;
vl_size dim = 128;
vl_size num = 10000;
vl_size numTrees = 1;
/*
* create a test data
*/
if((data = create_data(dim ,num)) == NULL){
printf("not enough memoey\n");
exit(1);
}
if(verbose) printf("has created a test data\n");
if((query = (float *)malloc(dim * sizeof(float))) == NULL){
printf("not enough memoey\n");
exit(1);
}
for(i = 0;i < dim; i++) query[i] = 0.5;
if(verbose) printf("has created a query\n");
/*
* build a kd-tree forest
*/
forest = kdtreebuild(1, dim, numTrees, VL_KDTREE_MEDIAN, num, data);
if(verbose) printf("has created a forest\n");
if(verbose && 0){
for(j = 0;j < numTrees; j++){
printf("dataIndex[%d] = [", j);
for(i = 0;i < forest->numData; i++){
printf("%d ",
forest->trees[j]->dataIndex[i].index + 1);
}
printf("]\n");
}
}
/*
* save
*/
save_data("data.bin", data, dim, num);
save_VlKDForest("forest.bin", forest);
/*
* search neighbors
*/
vl_size numNeighbors = 10;
unsigned int numComparisons = 0 ;
unsigned int maxNumComparisons = 0 ;
VlKDForestNeighbor * neighbors ;
vl_kdforest_set_max_num_comparisons (forest, maxNumComparisons) ;
neighbors = vl_malloc (sizeof(VlKDForestNeighbor) * numNeighbors) ;
numComparisons = vl_kdforest_query (forest, neighbors, numNeighbors,
query);
for(i = 0;i < numNeighbors; i++){
printf("%d %f\n",
neighbors[i].index + 1, neighbors[i].distance);
/* check distance */
if(fabs(
dist_l2(dim, query, &data[neighbors[i].index * dim]) -
neighbors[i].distance) > 1e-6){
printf("%d distance is different. %f\n",
dist_l2(dim, query, &data[neighbors[i].index * dim]) );
}
/* check order */
if(i != 0 && neighbors[i-1].distance > neighbors[i].distance){
printf("order is wrong.\n");
}
}
vl_free(neighbors);
vl_kdforest_delete(forest);
free(data);
free(query);
}
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;
}
