Beispiel #1
0
double closestPointsf(vector<R3> & src, vector<R3> & dst, vector<int> & indexes, vector<double> & distances)
{
	distances.clear();
	indexes.clear();
	#ifndef USE_KD

	Mat srcm = asMatRows(src), dstm = asMatRows(dst);
	vector<float> dists;
	double error = (double) knn(dstm, srcm, indexes, dists);
	for(int i = 0; i < dists.size(); i++) distances.push_back((double)dists[i]);
	double divisor = src.size() > 0 ? (double)(src.size()) : 1.0;
	return error / divisor;

	#else

    Pixel3DSet p1(src);
    Pixel3DSet p2(dst);
    LKDNode n; n.init(p2);
    n.split(p2);

    double error = 0.0;
    for(int i = 0; i < src.size(); i++)
    {
        R3 p = src[i];
        R3 w;
        int index = 0;
        n.NN(p2,p, index, w);
        indexes.push_back(index);
        float D = p.dist(p2[index]);
        distances.push_back(D);
        error += (D*D) / (float) src.size();
    }
    return error;
	#endif
}
void TEST_knn(char *file, int size_database, int quantity_atributes, int k) {
    int size_class_values = 2;
    struct database *data = mount_database(file, size_database, quantity_atributes);
    assert(data);
    data->class_values = (double *)calloc(size_class_values, sizeof(double));
    assert(data->class_values);
    data->size_class_values = size_class_values;
    data->class_values[0] = 1.0;
    data->class_values[1] = 0.0;

    int **confusion_matrix = create_confusion_matrix();

    knn(data, k, confusion_matrix);

    printf("TP:%d, FN:%d\nFP:%d, TN:%d\n",
        confusion_matrix[0][0], confusion_matrix[0][1],
        confusion_matrix[1][0], confusion_matrix[1][1]);

    double i = (double)(confusion_matrix[0][0] + confusion_matrix[1][1]);
    double j = (double)(confusion_matrix[0][0] + confusion_matrix[0][1] +
                confusion_matrix[1][0] + confusion_matrix[1][1]);
    printf("k:%d\naccuracy: %f\n", k, (double)(i/j));

    free_database(data);
    free_confusion_matrix(confusion_matrix);
}
Beispiel #3
0
static int 
knn_class(flt *x, struct codebook *cb, int nclass, int k)
{
  int *tbl = 0;
  int *ctab = 0;
  int i,n,c;
  
  tbl=(int*)malloc(k*sizeof(int));
  ctab=(int*)malloc(nclass*sizeof(int));
  ifn ( tbl && ctab) {
    if (tbl) free(tbl);
    if (ctab) free(ctab);
    error(NIL,"No memory",NIL);
  }
  
  knn(x, cb, k, tbl);
  for (i=0; i<nclass; i++)
    ctab[i] = 0;
  for (i=0; i<k; i++) {
    c = cb->code[tbl[i]].label;
    if (c>=0 && c<nclass)
      ctab[c]++;
  }
  n = c = -1;
  for (i=0; i<nclass; i++)
    if (ctab[i]>n) {
      c = i;
      n = ctab[i];
    } else if (ctab[i]==n) {
      c = -1;
    }
  if (tbl) free(tbl);
  if (ctab) free(ctab);
  return c;
}
Beispiel #4
0
void MLearn::runML(){
	Mat trainingData ( numTrainingPoints , 2 , CV_32FC1 ) ;
	Mat testData ( numTestPoints , 2 , CV_32FC1 ) ;
	randu ( trainingData ,0 ,1) ;
	randu ( testData ,0 ,1) ;
	Mat trainingClasses = labelData ( trainingData , eq ) ;
	Mat testClasses = labelData ( testData , eq ) ;
	plot_binary ( trainingData , trainingClasses , " Training Data " ) ;
	plot_binary ( testData , testClasses , " Test Data " ) ;
	svm ( trainingData , trainingClasses , testData , testClasses ) ;
	mlp ( trainingData , trainingClasses , testData , testClasses ) ;
	knn ( trainingData , trainingClasses , testData , testClasses , 3) ;
	bayes ( trainingData , trainingClasses , testData , testClasses ) ;
	decisiontree ( trainingData , trainingClasses , testData , testClasses ) ;
	waitKey () ;
}
Beispiel #5
0
double closestPointsf(Pixel3DSet & src, Pixel3DSet & dst, vector<int> & indexes, vector<double> & distances)
{
    //cout << "timing " << endl;
    double error;
    //LTimer t; t.start();
	distances.clear();
	indexes.clear();
	#ifndef USE_KD
	Mat srcm = asMatRows(src), dstm = asMatRows(dst);
	vector<float> dists;
	error = (double) knn(dstm, srcm, indexes, dists);
	for(int i = 0; i < dists.size(); i++) distances.push_back((double)dists[i]);
	double divisor = src.size() > 0 ? (double)(src.size()) : 1.0;
	error /= divisor;
	#else


	LKDNode n; n.init(dst);
    n.split(dst, 0, 15);
    //cout << n.averageLeafSize() << endl;
    error = 0.0;
    for(int i = 0; i < src.size(); i++)
    {
        R3 p = src[i];
        R3 w;
        int index = 0;
        n.NN(dst,p, index, w);
        //if(i%1000 == 0 )cout << i << " / " << src.size() << endl;
        indexes.push_back(index);
        float D = p.dist(dst[index]);
        distances.push_back(D);
        error += (D*D) / (float) src.size();
    }


	#endif
    //t.stop();
    //cout << "took " << t.getSeconds() << endl;

	return error;
}
void main()
{
int movie,rating,ex,usr,user,cnt,ind;

 	for(i=0;i<100000;i++)
 	{
 		scanf("%d%d%d%d",&usr,&movie,&rating,&ex);
 		r[usr-1][movie-1]=rating;
 	}
 root=knn(root);
 //display();
 node ptr;
 ptr=root;

 
 user=2;
 printf("the recommended items for %d are:\n",user);
 
 while(1)
 {
 	if(ptr->head==user)
 		break;
 	ptr=ptr->next;
 }
 for(j=0;j<1682;j++)
 {
 	cnt=0;
 	for(k=0;k<10;k++)
 	{
 		ind=ptr->array[k];
 		if((r[ind][j]!=0)&&(r[user][j]==0))
		{
		cnt++;
		}	 		
 	}
 	if(cnt>6)
 		printf("%d\t",j);
 	}	
} 	
Beispiel #7
0
/* NEW VERSION
 */
void linsched_create_normal_task_binary(struct elf_binary* binary, int niceval)
{
        struct sched_param params;
        unsigned long long time_slice;
        int query[3];
	
	query[0] = binary->size;
	query[1] = binary->bss;
	query[2] = binary->input_size; 
	/* If we cannot support any more tasks, return. */
        if (curr_task_id >= LINSCHED_MAX_TASKS)
                return;
	time_start = sched_clock();
		
	sim_param = (query[0]+query[1]+query[2])/(30*2);	
	time_slice = knn(&query[0], 3);
	time_slice *= 1000000;
	//time_slice = 500000000;
        /* Create "normal" task and set its nice value. */
        __linsched_tasks[curr_task_id] = __linsched_create_task_binary(binary->callback, time_slice);
        params.sched_priority = 0;
        


	sys_sched_setscheduler(__linsched_tasks[curr_task_id], SCHED_NORMAL,
                               &params);
        set_user_nice(__linsched_tasks[curr_task_id], niceval);

        /* Print message. */
        printf("Created normal task 0x%x with nice value %d.\n",
               (unsigned int)__linsched_tasks[curr_task_id], niceval);

        /* Increment task id. */
        curr_task_id++;



}
Beispiel #8
0
int main(int argc, char** argv)
{
  CoverTree<float, std::vector<float>, float (*const)(const std::vector<float>&, const std::vector<float>&)> tree(&euclidian);

  PointContainer data = generate(VECTORLENGTH);

  boost::posix_time::ptime time = boost::posix_time::microsec_clock::local_time();
  for(PointContainer::const_iterator it = data.begin(); it != data.end(); ++it)
  {
    tree.insert(*it);
  }
  std::cout << "Build time " << (boost::posix_time::microsec_clock::local_time() - time) << std::endl;

  std::ofstream stream("dump.txt");
  tree.dump(stream);

  Point zero(2, 0.f);
  time = boost::posix_time::microsec_clock::local_time();
  PointContainer result = knn(data, zero, KNNSIZE);
  std::cout << "Out time (linear) " << (boost::posix_time::microsec_clock::local_time() - time) << std::endl;

  time = boost::posix_time::microsec_clock::local_time();
  PointContainer result2 = tree.knn(zero, KNNSIZE);
  std::cout << "Out time (cover_tree) " << (boost::posix_time::microsec_clock::local_time() - time) << std::endl;

  bool boolean = true;
  for(int i = 0; i < std::min(result.size(), result2.size()); ++i)
  {
    for(int j = 0; j < POINTSIZE; ++j)
    {
      boolean = boolean && (result[i][j] == result2[i][j]);
    }
    std::cout << i << std::endl << result[i] << result2[i];
  }
  std::cout << "Result " << (boolean && (result.size() == result2.size())) << std::endl;
  return EXIT_SUCCESS;
}
Beispiel #9
0
/* Compute the nearest neighbors */
void SMOTE::computeNeighbors(cv::Mat minority, int nearestNeighbors,
    cv::Mat *neighbors) {
  cv::Size s = minority.size();
  int i, k = nearestNeighbors, max, index = 0;
  cv::Mat classes(s.height, 1, CV_32FC1);

  for (i = 0; i < s.height; i++) {
    classes.at<float>(i, 0) = index;
    index++;
  }

  cv::KNearest knn(minority, classes);
  max = (minority.rows > knn.get_max_k() ? knn.get_max_k() : minority.rows);
  knn.find_nearest(minority, (k > max ? max : k), 0, 0, neighbors, 0);

  // for (i = 0; i < (*neighbors).size().height; i++){
  //   std::cout << std::endl <<  nearestNeighbors << " vizinhos de i: " << i << std::endl;
  //   for (int x = 0; x < (*neighbors).size().width; x++){
  //     std::cout << (*neighbors).at<float>(i, x) << " ";
  //   }
  // }

  classes.release();
}
Beispiel #10
0
void  Apply_knn:: getAll_knn(int sizeOfMat,std::vector<float> label_bucket[],std::vector<float> values_of_bucket[])
{
    /**
    *   Begin   Apply knn to the Mat
    *
    **/
    std::vector<float> container[sizeOfMat];

    int k=15;
    cv::Mat result=Mat(sizeOfMat,k,CV_32F);



    /**
    *   Load data for knn
    **/
    CvKNearest knn(&trainningMat,&labelMat);


    /**
    *   Loading complet
    **/

        knn.find_nearest(&testingMat,k,&result);

        cout<<"get max_k\t"<<knn.get_max_k()<<"\n";
        cout<<"get total trainn samples\t"<<knn.get_sample_count()<<"\n";
        cout<<result;
        cout<<"\n";


    /**
    *  End Apply knn to the Mat
    *
    **/


    /**
    *   Put values in the bucket appropriately begins
    *
    **/
    cv::Mat tempMat=cv::Mat(&testingMat);
    for(int _i=0;_i<result.rows;_i++)
    {
        /**
        *   _i points to the first row of result which corresponds to the first row of testing sample.
        *   So points at testing sample of _i must be put to the same index of index_to_bucket
        **/
        for(int _j=0;_j<result.cols;_j++)
        {
            int key_of_map=result.at<float>(_i);/**here will be change jth index needs to be added. So check cols of result**/
            int index_to_bucket=vect_indexMap[key_of_map];
            cout<<index_to_bucket<<"\t"<<key_of_map<<"\n";

            /** index of testing sample serially from begin to end*/
            int index_to_testingSample=testingIndexMat.at<int>(_i);
            (label_bucket[index_to_bucket]).push_back(index_to_testingSample);




            float _x=tempMat.at<float>(_i,0);
            float _y=tempMat.at<float>(_i,1);
            (values_of_bucket[index_to_bucket]).push_back(_x);
            (values_of_bucket[index_to_bucket]).push_back(_y);
        }/**check this again**/

    }


    /**
    *   Put values in the bucket appropriately ends
    *
    **/

    /**
    *   Printing the values in the buckets begin
    *
    **/
        for(int _j=0;_j<result.rows-1;_j++)
        {
            //std::vector<float>::iterator it_to_label_bucket;
            cout<<"Contains of bucket:\t"<<(label_bucket[_j]).at(0)<<"\n";
            for(int _k=0;_k<(label_bucket[_j]).size();_k++)
            {
                cout<<(label_bucket[_j]).at(_k)<<"\t:";
                cout<<"_x\t:"<<(values_of_bucket[_j]).at(_k*2)<<"\t";
                cout<<"_y\t:"<<(values_of_bucket[_j]).at(_k*2+1);
                cout<<"\n";
            }
            cout<<"\n\n";
        }



    /**
    *   Printing the values in the buckets end
    *
    **/
    WriteGroupFile wgrF;
    wgrF.setFileName("gr_1nnD.txt");
    wgrF.openFile();
    wgrF.imageNumber=((label_bucket[0]).at(0))/500+1;

    if(wgrF.imageNumber==1)
    {
        /**
        *   Saving all contents of lable_bucket in
        **/
        cout<<"here\n";
        int total_groups=0;
        if(result.rows%2==0)
            total_groups=result.rows;
        else
            total_groups=result.rows-1;

        cout<<"Total groups:\t"<<total_groups<<"\n";

        getFirstImageVector(label_bucket,total_groups);
    }

    wgrF.setTotalBuckets(sizeOfMat);
    wgrF.writeGroups(label_bucket,values_of_bucket);
    wgrF.closeFile();
   // return listOfMat;
}
Beispiel #11
0
static std::pair<int,int> leave_one_out(KnnObject* o, int stop_threshold,
                                        int* selection_vector = 0,
                                        double* weight_vector = 0,
                                        std::vector<long>* indexes = 0) {
    int* selections = selection_vector;
    if (selections == 0) {
        selections = o->selection_vector;
    }

    double* weights = weight_vector;
    if (weights == 0) {
        weights = o->weight_vector;
    }

    assert(o->feature_vectors != 0);
    kNearestNeighbors<char*, ltstr, eqstr> knn(o->num_k);

    int total_correct = 0;
    int total_queries = 0;
    if (indexes == 0) {
        for (size_t i = 0; i < o->feature_vectors->size(); ++i/*, cur += o->num_features*/) {
            // We don't want to do the calculation if there is no
            // hope that kNN will return the correct answer (because
            // there aren't enough examples in the database).
            if (o->id_name_histogram[i] < int((o->num_k + 0.5) / 2)) {
                continue;
            }
            double* current_known;
            double* unknown = (*o->feature_vectors)[i];
            for (size_t j = 0; j < o->feature_vectors->size(); ++j) {
                current_known = (*o->feature_vectors)[j];
                if (i == j)
                    continue;
                double distance;
                compute_distance(o->distance_type, current_known, o->num_features,
                                 unknown, &distance, selections, weights);
                knn.add(o->id_names[j], distance);
            }
            knn.majority();
            if (strcmp(knn.answer[0].first, o->id_names[i]) == 0) {
                total_correct++;
            }
            knn.reset();
            total_queries++;
            if (total_queries - total_correct > stop_threshold)
                return std::make_pair(total_correct, total_queries);
        }
    } else {
        for (size_t i = 0; i < o->feature_vectors->size(); ++i) {
            if (o->id_name_histogram[i] < int((o->num_k + 0.5) / 2))
                continue;
            double* current_known;
            double* unknown = (*o->feature_vectors)[i];
            for (size_t j = 0; j < o->feature_vectors->size(); ++j) {
                current_known = (*o->feature_vectors)[j];
                if (i == j)
                    continue;
                double distance;
                if (o->distance_type == CITY_BLOCK) {
                    distance = city_block_distance_skip(current_known, unknown, selections, weights,
                                                        indexes->begin(), indexes->end());
                } else if (o->distance_type == FAST_EUCLIDEAN) {
                    distance = fast_euclidean_distance_skip(current_known, unknown, selections, weights,
                                                            indexes->begin(), indexes->end());
                } else {
                    distance = euclidean_distance_skip(current_known, unknown, selections, weights,
                                                       indexes->begin(), indexes->end());
                }

                knn.add(o->id_names[j], distance);
            }
            knn.majority();
            if (strcmp(knn.answer[0].first, o->id_names[i]) == 0) {
                total_correct++;
            }
            knn.reset();
            total_queries++;
            if (total_queries - total_correct > stop_threshold)
                return std::make_pair(total_correct, total_queries);
        }
    }
    return std::make_pair(total_correct, total_queries);
}
Beispiel #12
0
void mexFunction(int nout, mxArray *pout[], int nin, const mxArray *pin[]) {
  FILE *f = fopen("log.txt", "wt");
  fclose(f);

  if (nin < 2) { mexErrMsgTxt("nnmex called with < 2 input arguments"); }

  const mxArray *A = pin[0], *B = pin[1];
  const mxArray *ANN_PREV = NULL, *ANN_WINDOW = NULL, *AWINSIZE = NULL;
  int aw = -1, ah = -1, bw = -1, bh = -1;
  BITMAP *a = NULL, *b = NULL, *ann_prev = NULL, *ann_window = NULL, *awinsize = NULL;
  VECBITMAP<unsigned char> *ab = NULL, *bb = NULL;
  VECBITMAP<float> *af = NULL, *bf = NULL;

  if (mxGetNumberOfDimensions(A) != 3 || mxGetNumberOfDimensions(B) != 3) { mexErrMsgTxt("dims != 3"); }
  if (mxGetDimensions(A)[2] != mxGetDimensions(B)[2]) { mexErrMsgTxt("3rd dimension not same size"); }

  int mode = MODE_IMAGE;
  if (mxGetDimensions(A)[2] != 3) { // a discriptor rather than rgb
    if (mxIsUint8(A) && mxIsUint8(B)) { mode = MODE_VECB; } 
    else if (is_float(A) && is_float(B)) { mode = MODE_VECF; } 
    else { mexErrMsgTxt("input not uint8, single, or double"); }
  }

  Params *p = new Params();
  RecomposeParams *rp = new RecomposeParams();
  BITMAP *borig = NULL;
  if (mode == MODE_IMAGE) {
    a = convert_bitmap(A);
    b = convert_bitmap(B);
	borig = b;
    aw = a->w; ah = a->h;
    bw = b->w; bh = b->h;
  } 
  else if (mode == MODE_VECB) {
    ab = convert_vecbitmap<unsigned char>(A);
    bb = convert_vecbitmap<unsigned char>(B);
    if (ab->n != bb->n) { mexErrMsgTxt("3rd dimension differs"); }
    aw = ab->w; ah = ab->h;
    bw = bb->w; bh = bb->h;
    p->vec_len = ab->n;
  } 
  else if (mode == MODE_VECF) {
    af = convert_vecbitmap<float>(A);
    bf = convert_vecbitmap<float>(B);
    if (af->n != bf->n) { mexErrMsgTxt("3rd dimension differs"); }
    aw = af->w; ah = af->h;
    bw = bf->w; bh = bf->h;
    p->vec_len = af->n;
  }

  double *win_size = NULL;
  BITMAP *amask = NULL, *bmask = NULL;

  double scalemin = 0.5, scalemax = 2.0;  // The product of these must be one.
  /* parse parameters */
  int i = 2;
  int sim_mode = 0;
  int knn_chosen = -1;
  p->algo = ALGO_CPU;
  int enrich_mode = 0;
  if (nin > i && !mxIsEmpty(pin[i])) {
    if (mxStringEquals(pin[i], "cpu")) { p->algo = ALGO_CPU; }
    else if (mxStringEquals(pin[i], "gpucpu")) { p->algo = ALGO_GPUCPU; }
    else if (mxStringEquals(pin[i], "cputiled")) { p->algo = ALGO_CPUTILED; }
    else if (mxStringEquals(pin[i], "rotscale")) { sim_mode = 1; }
    else if (mxStringEquals(pin[i], "enrich")) { p->algo = ALGO_CPUTILED; enrich_mode = 1; }
    else { mexErrMsgTxt("Unknown algorithm"); }
  } i++;
  if (nin > i && !mxIsEmpty(pin[i])) { p->patch_w = int(mxGetScalar(pin[i])); } i++;
  if (nin > i && !mxIsEmpty(pin[i])) { p->nn_iters = int(mxGetScalar(pin[i])); } i++;
  if (nin > i && !mxIsEmpty(pin[i])) { p->rs_max = int(mxGetScalar(pin[i])); } i++;
  if (nin > i && !mxIsEmpty(pin[i])) { p->rs_min = int(mxGetScalar(pin[i])); } i++;
  if (nin > i && !mxIsEmpty(pin[i])) { p->rs_ratio = mxGetScalar(pin[i]); } i++;
  if (nin > i && !mxIsEmpty(pin[i])) { p->rs_iters = mxGetScalar(pin[i]); } i++;
  if (nin > i && !mxIsEmpty(pin[i])) { p->cores = int(mxGetScalar(pin[i])); } i++;
  if (nin > i && !mxIsEmpty(pin[i])) { bmask = convert_bitmap(pin[i]); } i++; // XC+
  if (nin > i && !mxIsEmpty(pin[i])) { 
    if (!mxIsDouble(pin[i])) { mexErrMsgTxt("\nwin_size should be of type double."); }
    win_size = (double*)mxGetData(pin[i]);
    if (mxGetNumberOfElements(pin[i])==1) { p->window_h = p->window_w = int(win_size[0]); }
    else if (mxGetNumberOfElements(pin[i])==2) { p->window_h = int(win_size[0]); p->window_w = int(win_size[1]); }
    else { mexErrMsgTxt("\nwin_size should be a scalar for square window or [h w] for a rectangular one."); }
  } i++;
  /* continue parsing parameters */
  // [ann_prev=NULL], [ann_window=NULL], [awinsize=NULL], 
  if (nin > i && !mxIsEmpty(pin[i])) { 
    ANN_PREV = pin[i];
    int clip_count = 0;
    ann_prev = convert_field(p, ANN_PREV, bw, bh, clip_count);       // Bug fixed by Connelly
  } i++;
  if (nin > i && !mxIsEmpty(pin[i])) { 
    ANN_WINDOW = pin[i];
    int clip_count = 0;
    ann_window = convert_field(p, ANN_WINDOW, bw, bh, clip_count);      
  } i++;
  if (nin > i && !mxIsEmpty(pin[i])) { 
    AWINSIZE = pin[i];
    awinsize = convert_winsize_field(p, AWINSIZE, aw, ah);  
    if (p->window_w==INT_MAX||p->window_h==INT_MAX) { p->window_w = -1; p->window_h = -1; }
  } i++;
  if (nin > i && !mxIsEmpty(pin[i])) { 
    knn_chosen = int(mxGetScalar(pin[i]));
    if (knn_chosen == 1) { knn_chosen = -1; }
    if (knn_chosen <= 0) { mexErrMsgTxt("\nknn is less than zero"); }
  } i++;
  if (nin > i && !mxIsEmpty(pin[i])) { 
    scalemax = mxGetScalar(pin[i]);
    if (scalemax <= 0) { mexErrMsgTxt("\nscalerange is less than zero"); }
    scalemin = 1.0/scalemax;
    if (scalemax < scalemin) {
      double temp = scalemax;
      scalemax = scalemin;
      scalemin = temp;
    }
  } i++;

  if (ann_window&&!awinsize&&!win_size) {
    mexErrMsgTxt("\nUsing ann_window - either awinsize or win_size should be defined.\n");
  }

  if (enrich_mode) {
	int nn_iters = p->nn_iters;
    p->enrich_iters = nn_iters/2;
	p->nn_iters = 2;
	if (A != B) { mexErrMsgTxt("\nOur implementation of enrichment requires that image A = image B.\n"); }
	if (mode == MODE_IMAGE) {
	  b = a;
	} else {
	  mexErrMsgTxt("\nEnrichment only implemented for 3 channel uint8 inputs.\n");
	}
  }

  init_params(p);
  if (sim_mode) {
    init_xform_tables(scalemin, scalemax, 1);
  }
  
  RegionMasks *amaskm = amask ? new RegionMasks(p, amask): NULL;

  BITMAP *ann = NULL; // NN field
  BITMAP *annd_final = NULL; // NN patch distance field
  BITMAP *ann_sim_final = NULL;

  VBMP *vann_sim = NULL;
  VBMP *vann = NULL;
  VBMP *vannd = NULL;

  if (mode == MODE_IMAGE) {
    // input as RGB image
    if (!a || !b) { mexErrMsgTxt("internal error: no a or b image"); }
    if (knn_chosen > 1) {
      p->knn = knn_chosen;
      if (sim_mode) { mexErrMsgTxt("rotating+scaling patches not implemented with knn (actually it is implemented it is not exposed by the wrapper)"); }
      PRINCIPAL_ANGLE *pa = NULL;
      vann_sim = NULL;
      vann = knn_init_nn(p, a, b, vann_sim, pa);
      vannd = knn_init_dist(p, a, b, vann, vann_sim);
      knn(p, a, b, vann, vann_sim, vannd, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, pa);
//      sort_knn(p, vann, vann_sim, vannd);
    } else if (sim_mode) {
      BITMAP *ann_sim = NULL;
      ann = sim_init_nn(p, a, b, ann_sim);
      BITMAP *annd = sim_init_dist(p, a, b, ann, ann_sim);
      sim_nn(p, a, b, ann, ann_sim, annd);
      if (ann_prev) { mexErrMsgTxt("when searching over rotations+scales, previous guess is not supported"); }
      annd_final = annd;
      ann_sim_final = ann_sim;
    } else {
      ann = init_nn(p, a, b, bmask, NULL, amaskm, 1, ann_window, awinsize);
      BITMAP *annd = init_dist(p, a, b, ann, bmask, NULL, amaskm);
      nn(p, a, b, ann, annd, amaskm, bmask, 0, 0, rp, 0, 0, 0, NULL, p->cores, ann_window, awinsize); 
      if (ann_prev) minnn(p, a, b, ann, annd, ann_prev, bmask, 0, 0, rp, NULL, amaskm, p->cores);  
      annd_final = annd;
    }
  } 
/*
  else if (mode == MODE_VECB) {
//    mexPrintf("mode vecb %dx%dx%d, %dx%dx%d\n", ab->w, ab->h, ab->n, bb->w, bb->h, bb->n);
//    mexPrintf("  %d %d %d %d\n", ab->get(0,0)[0], ab->get(1,0)[0], ab->get(0,1)[0], ab->get(0,0)[1]);
    if (!ab || !bb) { mexErrMsgTxt("internal error: no a or b image"); }
    ann = vec_init_nn<unsigned char>(p, ab, bb, bmask, NULL, amaskm);
    VECBITMAP<int> *annd = vec_init_dist<unsigned char, int>(p, ab, bb, ann, bmask, NULL, amaskm);
//    mexPrintf("  %d %d %d %p %p\n", annd->get(0,0)[0], annd->get(1,0)[0], annd->get(0,1)[0], amaskm, bmask);
    vec_nn<unsigned char, int>(p, ab, bb, ann, annd, amaskm, bmask, 0, 0, rp, 0, 0, 0, NULL, p->cores); 
    if (ann_prev) vec_minnn<unsigned char, int>(p, ab, bb, ann, annd, ann_prev, bmask, 0, 0, rp, NULL, amaskm, p->cores);  
    annd_final = vecbitmap_to_bitmap(annd);
    delete annd;
  } 
  else if (mode == MODE_VECF) {
//    mexPrintf("mode vecf %dx%dx%d, %dx%dx%d\n", af->w, af->h, af->n, bf->w, bf->h, bf->n);
//    mexPrintf("  %f %f %f %f\n", af->get(0,0)[0], af->get(1,0)[0], af->get(0,1)[0], af->get(0,0)[1]);
    if (!af || !bf) { mexErrMsgTxt("internal error: no a or b image"); }
    ann = vec_init_nn<float>(p, af, bf, bmask, NULL, amaskm);
    VECBITMAP<float> *annd = vec_init_dist<float, float>(p, af, bf, ann, bmask, NULL, amaskm);
    vec_nn<float, float>(p, af, bf, ann, annd, amaskm, bmask, 0, 0, rp, 0, 0, 0, NULL, p->cores); 
    if (ann_prev) vec_minnn<float, float>(p, af, bf, ann, annd, ann_prev, bmask, 0, 0, rp, NULL, amaskm, p->cores);  
    annd_final = create_bitmap(annd->w, annd->h);
    clear(annd_final);
    delete annd;
  }
*/
  else if(mode == MODE_VECB) {
    if (sim_mode) { mexErrMsgTxt("internal error: rotation+scales not implemented with descriptor mode"); }
    if (knn_chosen > 1) { mexErrMsgTxt("internal error: kNN not implemented with descriptor mode"); }
//    mexPrintf("mode vecb_xc %dx%dx%d, %dx%dx%d\n", ab->w, ab->h, ab->n, bb->w, bb->h, bb->n);
    // input as uint8 discriptors per pixel
    if (!ab || !bb) { mexErrMsgTxt("internal error: no a or b image"); }
    ann = XCvec_init_nn<unsigned char>(p, ab, bb, bmask, NULL, amaskm);
    VECBITMAP<int> *annd = XCvec_init_dist<unsigned char, int>(p, ab, bb, ann, bmask, NULL, amaskm);
    XCvec_nn<unsigned char, int>(p, ab, bb, ann, annd, amaskm, bmask, 0, 0, rp, 0, 0, 0, NULL, p->cores); 
    if (ann_prev) XCvec_minnn<unsigned char, int>(p, ab, bb, ann, annd, ann_prev, bmask, 0, 0, rp, NULL, amaskm, p->cores);  
    annd_final = vecbitmap_to_bitmap(annd);
    delete annd;
  } else if(mode == MODE_VECF) {
    if (sim_mode) { mexErrMsgTxt("internal error: rotation+scales not implemented with descriptor mode"); }
    if (knn_chosen > 1) { mexErrMsgTxt("internal error: kNN not implemented with descriptor mode"); }
    // input as float/double discriptors per pixel
    if (!af || !bf) { mexErrMsgTxt("internal error: no a or b image"); }
    ann = XCvec_init_nn<float>(p, af, bf, bmask, NULL, amaskm);
    VECBITMAP<float> *annd = XCvec_init_dist<float, float>(p, af, bf, ann, bmask, NULL, amaskm);
    XCvec_nn<float, float>(p, af, bf, ann, annd, amaskm, bmask, 0, 0, rp, 0, 0, 0, NULL, p->cores); 
    if (ann_prev) XCvec_minnn<float, float>(p, af, bf, ann, annd, ann_prev, bmask, 0, 0, rp, NULL, amaskm, p->cores);  
    annd_final = create_bitmap(annd->w, annd->h);
    clear(annd_final);
    delete annd;	
  }

  destroy_region_masks(amaskm);

  // output ann: x | y | patch_distance
  if(nout >= 1) {
    mxArray *ans = NULL;
    if (knn_chosen > 1) {
      if (sim_mode) { mexErrMsgTxt("rotating+scaling patches return value not implemented with knn"); }
      mwSize dims[4] = { ah, aw, 3, knn_chosen };
      ans = mxCreateNumericArray(4, dims, mxINT32_CLASS, mxREAL);
      int *data = (int *) mxGetData(ans);
      for (int kval = 0; kval < knn_chosen; kval++) {
        int *xchan = &data[aw*ah*3*kval+0];
        int *ychan = &data[aw*ah*3*kval+aw*ah];
        int *dchan = &data[aw*ah*3*kval+2*aw*ah];
        for (int y = 0; y < ah; y++) {
//          int *ann_row = (int *) ann->line[y];
//          int *annd_row = (int *) annd_final->line[y];
          for (int x = 0; x < aw; x++) {
//            int pp = ann_row[x];
            int pp = vann->get(x, y)[kval];
            int pos = y + x * ah;
            xchan[pos] = INT_TO_X(pp);
            ychan[pos] = INT_TO_Y(pp);
            dchan[pos] = vannd->get(x, y)[kval];
          }
        }
      }
    } else if (ann_sim_final) {
      mwSize dims[3] = { ah, aw, 5 };
      ans = mxCreateNumericArray(3, dims, mxSINGLE_CLASS, mxREAL);
      float *data = (float *) mxGetData(ans);
      float *xchan = &data[0];
      float *ychan = &data[aw*ah];
      float *dchan = &data[2*aw*ah];
      float *tchan = &data[3*aw*ah];
      float *schan = &data[4*aw*ah];
      double angle_scale = 2.0*M_PI/NUM_ANGLES;
      for (int y = 0; y < ah; y++) {
        int *ann_row = (int *) ann->line[y];
        int *annd_row = (int *) annd_final->line[y];
        int *ann_sim_row = ann_sim_final ? (int *) ann_sim_final->line[y]: NULL;
        for (int x = 0; x < aw; x++) {
          int pp = ann_row[x];
          int pos = y + x * ah;
          xchan[pos] = INT_TO_X(pp);
          ychan[pos] = INT_TO_Y(pp);
          dchan[pos] = annd_row[x];
          if (ann_sim_final) {
            int v = ann_sim_row[x];
            int tval = INT_TO_Y(v)&(NUM_ANGLES-1);
            int sval = INT_TO_X(v);

            tchan[pos] = tval*angle_scale;
            schan[pos] = xform_scale_table[sval]*(1.0/65536.0);
          }
        }
      }
    } else {
      mwSize dims[3] = { ah, aw, 3 };
      ans = mxCreateNumericArray(3, dims, mxINT32_CLASS, mxREAL);
      int *data = (int *) mxGetData(ans);
      int *xchan = &data[0];
      int *ychan = &data[aw*ah];
      int *dchan = &data[2*aw*ah];
      for (int y = 0; y < ah; y++) {
        int *ann_row = (int *) ann->line[y];
        int *annd_row = (int *) annd_final->line[y];
        for (int x = 0; x < aw; x++) {
          int pp = ann_row[x];
          int pos = y + x * ah;
          xchan[pos] = INT_TO_X(pp);
          ychan[pos] = INT_TO_Y(pp);
          dchan[pos] = annd_row[x];
        }
      }
    }
    pout[0] = ans;
  }

  // clean up
  delete vann;
  delete vann_sim;
  delete vannd;
  delete p;
  delete rp;
  destroy_bitmap(a);
  destroy_bitmap(borig);
  delete ab;
  delete bb;
  delete af;
  delete bf;
  destroy_bitmap(ann);
  destroy_bitmap(annd_final);
  destroy_bitmap(ann_sim_final);
  if (ann_prev) destroy_bitmap(ann_prev);
  if (ann_window) destroy_bitmap(ann_window);
  if (awinsize) destroy_bitmap(awinsize);
}
int main (){
    char file[50];//name of file
    int nclus;//number of clusters
    //float *Cone, *Ctwo, *temp, *temp2;
    
    
    /*--------------------------------------------------------------------------
    -------------get input parameters
    --------------------------------------------------------------------------*/
    
    
    //get name of file to open
    printf("what is the name of your file?");    
    if (scanf("%s", &file[0]) != 1){ //read in value and make sure it is valid name
               printf("error: filemane invalid!\n");
               exit(EXIT_FAILURE); 
    }
    printf("filename is %s\n", file);
    
    //get number of clusters
    printf("how many clusters do you want to find?"); 
     if (scanf("%d", &nclus) != 1){ //read in value and make sure it is valid number
               printf("error: number invalid!\n");
               exit(EXIT_FAILURE); 
    }
    printf("number of k clusters is %d\n", nclus);
        
        
    /*--------------------------------------------------------------------------
    -------------open and read input file
    --------------------------------------------------------------------------*/
        
    //open input file 
    FILE *fp;
    if ((fp = fopen(file,"r")) == NULL){
       printf("Error:cannot read the file %s\n", file);        
    }else{
       printf("success opening file %s\n", file); 
    }
    
    //read number of items and attributes
    int items, attributes;
    fscanf(fp,"%d",&items);
    fscanf(fp,"%d",&attributes);
    printf ("items %d attributes %d\n", items, attributes);
    getchar();
    
    //Create nodes    
    Node *head = (Node *) malloc (sizeof(Node)); 
    Node *node = (Node *) malloc (sizeof(Node));
    
    float *temp  = (float *)malloc(items*attributes*sizeof(float));
    //read file
    printf("reading file\n");
    int i, j; //counters
    for (i=0; i < items; i++){//for each item
        printf("reading item %d\n",i);      
          for (j=0; j < attributes; j++){
              fscanf(fp,"%f",&temp[(attributes)*i+j]);              
              //printf("read attribute %d, %f\n",j,temp[(attributes)*i+j]);
              
          }     

          node = addData(nclus+1,&temp[(attributes)*i]);  
          append(head,node);
    }
       
       
    /*--------------------------------------------------------------------------
    -------------get initial means
    --------------------------------------------------------------------------*/
        
    float *means = (float *)malloc(nclus*attributes*sizeof(float));
    //float *means_b = (float *)malloc(nclus*attributes*sizeof(float)); 
    
    int index;
    node = head;
    //printf("node...%f %f\n", node->att[0], node->att[1]); 
    for (i=0;i<nclus;i++){
        node = node->next;
        //printf("node...%f %f\n", node->att[0], node->att[1]); 
        printf("\n\ninitial center for cluster %d:\n",i);
        for (j=0;j<attributes;j++){ 
            index =  (attributes)*(i)+j;    
            means[index] = node->att[j];       
            printf("attribute %d: %f\n", j, node->att[j]);    
        }
    }
    printf("press enter\n");
    getchar();
    
   /*--------------------------------------------------------------------------
    -------------run k-means algorithm
    --------------------------------------------------------------------------*/
   
   //declare variables for k-means algo
   float *att_sum = (float *)malloc(nclus*attributes*sizeof(float)); //sum of each column for each cluster
   float *sqerr_sum = (float *)malloc(nclus*sizeof(float)); //keep track of rmse
   float *rmse = (float *)malloc(nclus*sizeof(float)); //keep track of rmse
   float *rmsediff = (float *)malloc(nclus*sizeof(float)); //differences in rmse
   int *cnt = (int *)malloc(nclus*sizeof(int)); //number of elements in each cluster
   
   
   float *last_rmse = (float *)malloc(nclus*sizeof(float));  
   int test = 0;
   int count = 0;
   do{//repeat until test = 1 (RMSE converges)
      test = kmeans(head,&means[0],nclus,&last_rmse[0], attributes,
           &att_sum[0], &sqerr_sum[0], &rmse[0], &rmsediff[0], &cnt[0]);
      printf("press enter for next iteration\n");
      getchar();
      //printf("test %d\n", test); 
      count ++;
      if (count > 100) 
         test = 1; 
   }while(test == 0);
          
    
   /*--------------------------------------------------------------------------
    -------------print results in output file
    --------------------------------------------------------------------------*/
    FILE *out;
    if ((out = fopen("output_gbm.csv","w")) == NULL){
       printf("Error:cannot read the file output.txt\n");        
    }else{
       printf("success opening output file output.txt for output\n"); 
    }
    node = head;
    while(node->next != NULL){
        node = node->next;      

         for (j=0;j<attributes;j++) { 
             fprintf(out, "%f,", node->att[j]);
         }
         fprintf(out,"%d\n",node->kclus);
    }
    fclose(out);
    fclose (fp) ; 
    
    
    /*--------------------------------------------------------------------------
    -------------run k-nearest neighbor algorithm
    --------------------------------------------------------------------------*/
    int response;
    printf("if you want to run k-nearest neighbor type the number 1 and press enter, otherwise press any other key: "); 
     if (scanf("%d", &response) != 1){ //read in value and make sure it is valid number
               printf("error: number invalid!\n");
               exit(EXIT_FAILURE); 
    }
    printf("response is %d\n", response);
    //run k-nn algorithm
    
    if (response == 1){
         knn(head, nclus); //knn call function
    }
    
    
    free(last_rmse);
    free(means);
    free(att_sum); 
    free(sqerr_sum); 
    free(rmse); 
    free(rmsediff); 
    free(cnt);
    

    return 1; 
}
Beispiel #14
0
bool ccGriddedTools::ComputeNormals(ccPointCloud* cloud,
									const std::vector<int>& indexGrid,
									int width,
									int height,
									bool* canceledByUser/*=0*/,
									int kernelWidth/*=3*/ )
{
	//init
	bool result = true;
	if (canceledByUser)
		*canceledByUser = false;

	//try to compute normals
	if (cloud->reserveTheNormsTable())
	{
		//progress dialog
		ccProgressDialog pdlg(true);
		CCLib::NormalizedProgress nprogress(&pdlg,cloud->size());
		pdlg.setMethodTitle("Compute normals");
		pdlg.setInfo(qPrintable(QString("Number of points: %1").arg(cloud->size())));
		pdlg.start();

		const int* _indexGrid = &(indexGrid[0]);
		CCLib::ReferenceCloud knn(cloud);
		
		//neighborhood 'half-width' (total width = 1 + 2*kernelWidth) 
		//max number of neighbours: (1+2*nw)^2
		knn.reserve((1+2*kernelWidth)*(1+2*kernelWidth));

		//for each grid cell
		for (int j=0; j<height; ++j)
		{
			for (int i=0; i<width; ++i, ++_indexGrid)
			{
				if (*_indexGrid >= 0)
				{
					unsigned pointIndex = static_cast<unsigned>(*_indexGrid);
					//add the point itself
					knn.clear(false);
					knn.addPointIndex(pointIndex); //warning: indexes are shifted (0 = no point)
					const CCVector3* P = cloud->getPoint(pointIndex);

					//look for neighbors
					for (int v=std::max(0,j-kernelWidth); v<std::min<int>(height,j+kernelWidth); ++v)
					{
						if (v != j)
						{
							for (int u=std::max(0,i-kernelWidth); u<std::min<int>(width,i+kernelWidth); ++u)
							{
								if (u != i)
								{
									int indexN = indexGrid[v*width + u];
									if (indexN >= 0)
									{
										//we don't consider points with a too much different depth than the central point
										const CCVector3* Pn = cloud->getPoint(static_cast<unsigned>(indexN));
										if (fabs(Pn->z - P->z) <= std::max(fabs(Pn->x - P->x),fabs(Pn->y - P->y)))
											knn.addPointIndex(static_cast<unsigned>(indexN)); //warning: indexes are shifted (0 = no point)
									}
								}
							}
						}
					}

					CCVector3 N(0,0,1);
					if (knn.size() >= 3)
					{
						CCLib::Neighbourhood Z(&knn);

						//compute normal with quadratic func. (if we have enough points)
						if (false/*knn.size() >= 6*/)
						{
							uchar hfDims[3];
							const PointCoordinateType* h = Z.getHeightFunction(hfDims);
							if (h)
							{
								const CCVector3* gv = Z.getGravityCenter();
								assert(gv);

								const uchar& iX = hfDims[0];
								const uchar& iY = hfDims[1];
								const uchar& iZ = hfDims[2];

								PointCoordinateType lX = P->u[iX] - gv->u[iX];
								PointCoordinateType lY = P->u[iY] - gv->u[iY];

								N.u[iX] = h[1] + (2 * h[3] * lX) + (h[4] * lY);
								N.u[iY] = h[2] + (2 * h[5] * lY) + (h[4] * lX);
								N.u[iZ] = -PC_ONE;

								N.normalize();
							}
						}
						else
#define USE_LSQ_PLANE
#ifdef USE_LSQ_PLANE
						{
							//compute normal with best fit plane
							const CCVector3* _N = Z.getLSQPlaneNormal();
							if (_N)
								N = *_N;
						}
#else
						{
							//compute normals with 2D1/2 triangulation
							CCLib::GenericIndexedMesh* theMesh = Z.triangulateOnPlane();
							if (theMesh)
							{
								unsigned faceCount = theMesh->size();
								N.z = 0;

								//for all triangles
								theMesh->placeIteratorAtBegining();
								for (unsigned j=0; j<faceCount; ++j)
								{
									const CCLib::TriangleSummitsIndexes* tsi = theMesh->getNextTriangleIndexes();
									//we look if the central point is one of the triangle's vertices
									if (tsi->i1 == 0 || tsi->i2 == 0|| tsi->i3 == 0)
									{
										const CCVector3 *A = knn.getPoint(tsi->i1);
										const CCVector3 *B = knn.getPoint(tsi->i2);
										const CCVector3 *C = knn.getPoint(tsi->i3);

										CCVector3 no = (*B - *A).cross(*C - *A);
										//no.normalize();
										N += no;
									}
								}

								delete theMesh;
								theMesh = 0;

								//normalize the 'mean' vector
								N.normalize();
							}
						}
#endif
					}

					//check normal vector sign
					CCVector3 viewVector = *P /*- cloudTrans.getTranslationAsVec3D()*/; //clouds are still in their local coordinate system!
					if (viewVector.dot(N) > 0)
						N *= -PC_ONE;
					cloud->addNorm(N);

					//progress
					if (!nprogress.oneStep())
					{
						result = false;
						if (canceledByUser)
							*canceledByUser = true;
						ccLog::Warning("[ComputeNormals] Process canceled by user!");
						//early stop
						j = height;
						break;
					}
				}
			}
		}

		if (!result)
		{
			cloud->unallocateNorms();
		}
	}
	else
	{
		ccLog::Warning("[ComputeNormals] Not enough memory!");
	}

	return result;
}
Beispiel #15
0
float knn(Mat& m_destinations, Mat& m_object, vector<int>& ptpairs)
{
    vector<float> dists;
    return knn(m_destinations, m_object, ptpairs, dists);
}
Beispiel #16
0
int main (int argc, const char * argv[])
{
    // choose which zero of autocorrelation should be set as delay parameter
    int delay_choice =2;
    int embed_dimension =3;
    int num_neighbours = 15;
    long num_of_points_retained=500;
    int percentile =70;
    long output_len=2*(((float)percentile)/100)*num_of_points_retained;

    printf("%ld output_len =",output_len);
    float *output = malloc(output_len* sizeof(float));

    printf("Density based subsampling                                                                                                      running \n");
    if (argc != 2) {
        fprintf(stderr, "Expecting wav file as argument\n");
        return 1;
    }

    // Open sound file that comes in as a command line argument
    SF_INFO sndInfo;
    SNDFILE *sndFile = sf_open(argv[1], SFM_READ, &sndInfo);
    if (sndFile == NULL) {
        fprintf(stderr, "Error reading source file '%s': %s\n", argv[1], sf_strerror(sndFile));
        return 1;
    }

    // Check format - 16bit PCM
    if (sndInfo.format != (SF_FORMAT_WAV | SF_FORMAT_PCM_16)) {
        fprintf(stderr, "Input should be 16bit Wav\n");
        sf_close(sndFile);
        return 1;
    }


    // Now we know the length of the wav file, we can create a buffer for it, in this case, we are creating a double array.

    // Allocate memory
    float *buffer = malloc(sndInfo.frames * sizeof(float)* sndInfo.channels);
    if (buffer == NULL)
    {
        fprintf(stderr, "Could not allocate memory for data\n");
        sf_close(sndFile);
        return 1;
    }

    // This next step, actually reads in the wav file data. This function automatically converts the whichever format the audio file data is in to doubles. The library can convert to a number of different formats.
    // Load data
    long numFrames = sf_readf_float(sndFile, buffer, sndInfo.frames);

    // Check correct number of samples loaded
    if (numFrames != sndInfo.frames) {
        fprintf(stderr, "Did not read enough samples for source\n");
        sf_close(sndFile);
        free(buffer);
        return 1;
    }

    // Now just output some info about the wav file
    printf("Read %ld samples from %s, Sample rate: %d, Length: %fs\n",
           numFrames, argv[1], sndInfo.samplerate, (float)numFrames/sndInfo.samplerate);

    // extract a single channel out
    float *buffer_singlechannel = malloc(sndInfo.frames * sizeof(float));


    long i=0;
    for (long f=0 ; f<numFrames ; f++) {

        buffer_singlechannel[f]= buffer[i];   // Channel 1
        i+=sndInfo.channels;

    }
    // free the buffer with multiple channel input
    free(buffer);

    // array to store the autocorrelation function
    double *buffer_autocorrelation = malloc((2*sndInfo.frames +1)* sizeof(double));

    // calculate autocorrelation
    xcorr( buffer_singlechannel,  buffer_singlechannel, buffer_autocorrelation, sndInfo.frames, 0,sndInfo.frames, 1, 1, sndInfo.frames,sndInfo.frames, sndInfo.frames, sndInfo.frames);

    // choose delay to be second zero of auto correlation
    long long delay = zeroCrossing(buffer_autocorrelation, 2*sndInfo.frames +1, delay_choice);
    printf("Delay chosen = %lld\n",delay);

    long long delay_embd_length=  (sndInfo.frames -(delay*embed_dimension)+2)* embed_dimension;

    //create delay embedding and store in a linear array in row major form
    float *buffer_delayembedding =malloc(delay_embd_length*sizeof(float));

    long long k1=0;
    for (long long l=(delay*embed_dimension)-2; l<sndInfo.frames; l=l+1) {
        buffer_delayembedding[k1]=buffer_singlechannel[l];
        buffer_delayembedding[k1+1]=buffer_singlechannel[l-delay];
        buffer_delayembedding[k1+2]=buffer_singlechannel[l-2*delay];

        // printf("%f   %f   %f\n", buffer_delayembedding[k1],buffer_delayembedding[k1+1],buffer_delayembedding[k1+2]);
        k1=k1+embed_dimension;
    }

    int *array =malloc(num_of_points_retained *sizeof(int));


    random_selector( delay_embd_length/ embed_dimension  ,num_of_points_retained , array);


    for (int i=0; i<num_of_points_retained; i++) {
        //  printf("%d\n",array[i]);
    }
    float *buffer_delayembedding_selec =malloc(num_of_points_retained*embed_dimension*sizeof(float));

    float * density_vals =malloc(num_of_points_retained* sizeof(float));

    printf("total len = %lld\n ", delay_embd_length/3 );
    printf("buffer len = %ld\n", num_of_points_retained*embed_dimension);
    printf("num_of_points_retained = %ld\n", num_of_points_retained);
    for (int i=0; i<num_of_points_retained; i=i+1)
    {
        int loc=(array[i]-1)*embed_dimension;
        // printf("i :%d  loc=%d  array[i]: %d \n",i, loc, array[i]);

        buffer_delayembedding_selec[3*i]=buffer_delayembedding[loc];
        buffer_delayembedding_selec[3*i+1]=buffer_delayembedding[loc+1];
        buffer_delayembedding_selec[3*i+2]=buffer_delayembedding[loc+2];

        //  printf("buffer selec [%d] = %f ", 3*i, buffer_delayembedding_selec[3*i]);
        //  printf("[%d] = %f ", 3*i+1, buffer_delayembedding_selec[3*i+1]);
        //  printf("[%d] = %f \n", 3*i+2, buffer_delayembedding_selec[3*i+2]);

    }
    //  for (int i=0; i<delay_embd_length/ embed_dimension ; i++)
    // {
    //     printf("% d th original :%f   %f   %f\n",i, buffer_delayembedding [3*i],buffer_delayembedding [3*i+1],buffer_delayembedding [3*i+2]);
    // }

    knn (buffer_delayembedding_selec, density_vals , (num_of_points_retained), num_neighbours);
    // free all arrays used till now except the single channel wave file and close the sndFile object

    sf_close(sndFile);

    //desnity based subsampling
    float * density_vals_temp =malloc(num_of_points_retained* sizeof(float));
    memcpy(density_vals_temp,density_vals,num_of_points_retained* sizeof(float));


    qsort(density_vals_temp, num_of_points_retained, sizeof(float), cmpfunc);

    float key=findNumber(100-percentile,density_vals_temp,500);
    // Function call and the print statement
    // printf(" \n %d percentile: %.4lf \n", percentile, key);
    printf(" \n the linear array output contains the subsampled point cloud \n");
    //for (int kk=0; kk<num_of_points_retained; kk++) {
    //    printf("%d index %f \n", kk,density_vals_temp[kk]);
    //}

    free(density_vals_temp);
    int counter2=0;
    for( int counter = 0 ; counter < num_of_points_retained; counter++)
    {
        if (density_vals[counter]>=key && counter2<output_len/2)
        {
            output[2*counter2]=buffer_delayembedding_selec[3*counter];
            output[2*counter2+1]=buffer_delayembedding_selec[3*counter+1];
            //printf("%d output %.4lf , %.4lf\n", counter2,output[2*counter2],output[2*counter2+1]);
            //printf("%d output %.4lf , %.4lf\n", counter,buffer_delayembedding_selec[3*counter],buffer_delayembedding_selec[3*counter+1]);
            counter2++;
        }
    }

    free(buffer_singlechannel);
    free(buffer_autocorrelation);
    free(buffer_delayembedding);
    free(array);
    free(buffer_delayembedding_selec);
    free(density_vals);

    printf("Density based subsampling End\n");
    free(output);
    return 0;
}
Beispiel #17
0
void vlad_compute(int k, int d, const float *centroids, int n, const float *v,int flags, float *desc) 
{

	int i,j,l,n_quantile,i0,i1,ai,a,ma,ni;
	int *perm ;
	float un , diff;
	float *tab,*u,*avg,*sum,*mom2,*dists;
	int *hist,*assign;


	if(flags<11 || flags>=13) 
	{
		assign=ivec_new(n);

		nn(n,k,d,centroids,v,assign,NULL,NULL);    

		if(flags==6 || flags==7) 
		{
			n_quantile = flags==6 ? 3 : 1;
			fvec_0(desc,k*d*n_quantile);
			perm      = ivec_new(n);
			tab       = fvec_new(n);
			ivec_sort_index(assign,n,perm);
			i0=0;
			for(i=0;i<k;i++) 
			{
				i1=i0;
				while(i1<n && assign[perm[i1]]==i) 
				{
					i1++;
				}

				if(i1==i0) continue;

				for(j=0;j<d;j++) 
				{        
					for(l=i0;l<i1;l++)
					{
						tab[l-i0]=v[perm[l]*d+j];
					}
					ni=i1-i0;
					fvec_sort(tab,ni);
					for(l=0;l<n_quantile;l++) 
					{
						desc[(i*d+j)*n_quantile+l]=(tab[(l*ni+ni/2)/n_quantile]-centroids[i*d+j])*ni;
					}
				}

				i0=i1;
			}
			free(perm);
			free(tab);
		} 
		else if(flags==5) 
		{
			fvec_0(desc,k*d);

			for(i=0;i<n;i++) 
			{
				for(j=0;j<d;j++) 
				{
					desc[assign[i]*d+j]+=v[i*d+j];
				}
			}

		} 
		else if(flags==8 || flags==9) 
		{
			fvec_0(desc,k*d);

			u   = fvec_new(d);

			for(i=0;i<n;i++) 
			{
				fvec_cpy(u,v+i*d,d);
				fvec_sub(u,centroids+assign[i]*d,d);
				un=(float)sqrt(fvec_norm2sqr(u,d));

				if(un==0) continue;
				if(flags==8) 
				{        
					fvec_div_by(u,d,un);
				} else if(flags==9) 
				{
					fvec_div_by(u,d,sqrt(un));
				}

				fvec_add(desc+assign[i]*d,u,d);

			}
			free(u);
		} 
		else if(flags==10) 
		{
			fvec_0(desc,k*d);

			for(i=0;i<n;i++) 
			{
				for(j=0;j<d;j++) 
				{
					desc[assign[i]*d+j]+=v[i*d+j];
				}
			}

			for(i=0;i<k;i++) 
			{
				fvec_normalize(desc+i*d,d,2.0);  
			}

		} 
		else if(flags==13) 
		{

			fvec_0(desc,k*d);

			for(i=0;i<n;i++) 
			{
				for(j=0;j<d;j++) 
				{
					desc[assign[i]*d+j]+=(float)sqr(v[i*d+j]-centroids[assign[i]*d+j]);
				}
			}     

		} 
		else if(flags==14) 
		{
			avg = fvec_new_0(k*d);

			for(i=0;i<n;i++) 
			{
				for(j=0;j<d;j++) 
				{
					avg[assign[i]*d+j]+=v[i*d+j]-centroids[assign[i]*d+j];
				}
			}

			hist=ivec_new_histogram(k,assign,n);

			for(i=0;i<k;i++) 
			{
				if(hist[i]>0) 
				{
					for(j=0;j<d;j++) 
					{
						avg[i*d+j]/=hist[i];
					}
				}
			}

			free(hist);

			fvec_0(desc,k*d);
			for(i=0;i<n;i++) 
			{
				for(j=0;j<d;j++) 
				{
					desc[assign[i]*d+j]+=(float)(sqr(v[i*d+j]-centroids[assign[i]*d+j]-avg[assign[i]*d+j]));
				}
			}

			fvec_sqrt(desc,k*d);

			free(avg);
		}  
		else if(flags==15) 
		{
			fvec_0(desc,k*d*2);
			sum = desc;

			for(i=0;i<n;i++) 
			{
				for(j=0;j<d;j++) 
				{
					sum[assign[i]*d+j]+=v[i*d+j]-centroids[assign[i]*d+j];
				}
			}

			hist = ivec_new_histogram(k,assign,n);

			mom2 = desc+k*d;

			for(i=0;i<n;i++) 
			{
				ai=assign[i];
				for(j=0;j<d;j++) 
				{
					mom2[ai*d+j]+=(float)(sqr(v[i*d+j]-centroids[ai*d+j]-sum[ai*d+j]/hist[ai]));
				}
			}
			fvec_sqrt(mom2,k*d);
			free(hist);


		} 
		else if(flags==17) 
		{
			fvec_0(desc,k*d*2);

			for(i=0;i<n;i++) 
			{
				for(j=0;j<d;j++) 
				{
					diff=v[i*d+j]-centroids[assign[i]*d+j];
					if(diff>0)
					{
						desc[assign[i]*d+j]+=diff;
					}
					else 
					{
						desc[assign[i]*d+j+k*d]-=diff;
					}
				}
			}

		} 
		else 
		{
			fvec_0(desc,k*d);

			for(i=0;i<n;i++) 
			{
				for(j=0;j<d;j++) 
				{
					desc[assign[i]*d+j]+=v[i*d+j]-centroids[assign[i]*d+j];
				}
			}


			if(flags==1) 
			{
				hist=ivec_new_histogram(k,assign,n);
				/* printf("unbalance factor=%g\n",ivec_unbalanced_factor(hist,k)); */

				for(i=0;i<k;i++) 
				{
					for(j=0;j<d;j++) 
					{
						desc[i*d+j]/=hist[i];    
					}
				}
				free(hist);
			}

			if(flags==2) 
			{
				for(i=0;i<k;i++) 
				{
					fvec_normalize(desc+i*d,d,2.0);
				}
			}

			if(flags==3 || flags==4) 
			{
				assert(!"not implemented");
			}

			if(flags==16) 
			{
				hist=ivec_new_histogram(k,assign,n);
				for(i=0;i<k;i++) 
				{
					if(hist[i]>0) 
					{
						fvec_norm(desc+i*d,d,2);
						fvec_mul_by(desc+i*d,d,sqrt(hist[i]));
					}
				}
				free(hist);
			}


		}
		free(assign);
	} 
	else if(flags==11 || flags==12) 
	{
		ma=flags==11 ? 4 : 2;
		assign=ivec_new(n*ma);

		dists=knn(n,k,d,ma,centroids,v,assign,NULL,NULL);    

		fvec_0(desc,k*d);

		for(i=0;i<n;i++) 
		{
			for(j=0;j<d;j++) 
			{
				for(a=0;a<ma;a++) 
				{
					desc[assign[ma*i+a]*d+j]+=v[i*d+j]-centroids[assign[ma*i+a]*d+j];
				}
			}
		} 

		free(dists);

		free(assign);
	}

}