QRgb NwwMapImage::pixel( double const lonRad, double const latRad ) { double const x = lonRadToPixelX( lonRad ); double const y = latRadToPixelY( latRad ); switch ( m_interpolationMethod ) { case NearestNeighborInterpolation: return nearestNeighbor( x, y ); case BilinearInterpolation: return bilinearInterpolation( x, y ); default: return nearestNeighbor( x, y ); } }
void scrambleNotes(Array<NoteUnit>& notes) { Array<NoteUnit> notes2; notes2 = notes; int i; for (i=0; i<notes2.getSize(); i++) { notes2[i].random = rand(); } if (voiceQ) { qsort(notes.getBase(), notes.getSize(), sizeof(NoteUnit), compareNoteSortTrack); qsort(notes2.getBase(), notes2.getSize(), sizeof(NoteUnit), compareNoteUnitTrack); } else { qsort(notes2.getBase(), notes2.getSize(), sizeof(NoteUnit), compareNoteUnit); } if (neighborQ) { for (i=0; i<notes.getSize(); i++) { notes[i].newpitch = nearestNeighbor(notes[i].pitch, notes2[i].pitch); } } else { for (i=0; i<notes.getSize(); i++) { notes[i].newpitch = notes2[i].pitch; } } }
void NN::clusterize(AbstractMetric *pMetric) { int nObjectCount = _pContainer->ids().size(); list<Cluster*> lsClusters; for (int i = 0; i < nObjectCount; i++) { Cluster *pC = new Cluster(_pContainer); pC->addObject(_pContainer->getByIndex(i)); lsClusters.push_back(pC); } srand(time(NULL)); //Pick a random cluster index int nRandomIndex = rand() % nObjectCount; Cluster *pC = NULL, *pC2 = NULL; //Find the cluster for that index { list<Cluster*>::iterator iC; int i = 0; for (iC = lsClusters.begin(); iC != lsClusters.end() && i < nObjectCount; iC++, i++) { if (i == nRandomIndex) { pC = *iC; break; } } } if (pC == NULL) { fprintf(stderr, "Failed to generate random cluster for NN!\n"); return; } Cluster *pC0 = *(lsClusters.begin()); while (lsClusters.size() > 1) { pC = nearestNeighbor(pC0, lsClusters, pMetric); pC2 = nearestNeighbor(pC, lsClusters, pMetric); if (pC0 == pC2) { Cluster *pC_new = new Cluster(_pContainer); pC_new->addCluster(pC); pC_new->addCluster(pC2); lsClusters.push_back(pC_new); lsClusters.remove(pC); lsClusters.remove(pC2); pC0 = *(lsClusters.begin()); } else { pC0 = pC2; } } };
void findPairs(double thresholdSIFT, std::vector<cv::KeyPoint>& keypoints1, cv::Mat& descriptors1, std::vector<cv::KeyPoint>& keypoints2, cv::Mat& descriptors2, std::vector<cv::Point2f>& srcPoints, std::vector<cv::Point2f>& dstPoints) { for (int i = 0; i < descriptors1.rows; i++) { clear_line(); fprintf(stderr,"Checking SIFT pairs , threshold %0.2f : \n",thresholdSIFT); fprintf(stderr,"%u / %u checks - %u matches \n",i, descriptors1.rows , srcPoints.size()); cv::KeyPoint pt1 = keypoints1[i]; cv::Mat desc1 = descriptors1.row(i); int nn = nearestNeighbor(thresholdSIFT,desc1, keypoints2, descriptors2); if (nn >= 0) { cv::KeyPoint pt2 = keypoints2[nn]; srcPoints.push_back(pt1.pt); dstPoints.push_back(pt2.pt); } } }
int main(int argc,char* argv[]) { int k; clock_t start, end; float seconds = 0; int r; double minDist = BIG_NUM; double totalDist; int i,seed,storeSeed; char* x; struct Arr2D* Array = create2DArr(4,40000); //1 = city//2 = x // 3 = y// 4 = order FILE* fp; getCityXY(fp,argv[1],Array); for(i = 0; i < Array->size[CITY]; i++) { Array->array[ORDER][i] = -1; } if (Array->size[CITY] > 1000) { printf("MAX SOLVE TIME = %d Seconds\n",SOLVE_TIME); do{ start = clock(); seed = (rand())%(Array->size[CITY]); totalDist = nearestNeighbor(Array,seed); if(totalDist < minDist) { storeSeed = seed; minDist = totalDist; } end = clock(); seconds += (float)(end - start) / CLOCKS_PER_SEC; }while(seconds <= SOLVE_TIME); } else { storeSeed = RepNearestNeighbor(Array); } minDist = nearestNeighbor(Array,storeSeed); x = strcat(argv[1],".tour"); outPutFile(fp,x,Array,minDist); delete2DArr(Array); printf("Success!\n"); return 0; }
int main(int argc, char** argv) { if (argc != 4) { cerr << "Usage: " << argv[0] << " dim n area." << endl; return -1; } int dim = atol(argv[1]); int n = atol(argv[2]); double area = atof(argv[3]); if(dim <= 0) { cerr << "Dimension should be larger than 0." << endl; return -1; } if(n <= 0) { cerr << "The number of query points should be larger than 0." << endl; return -1; } if(area <= 0 || area > 1) { cerr << "the area of query points should be in (0, 1]." << endl; return -1; } /*read static data set*/ vector <Point> P; ifstream in("../data.ini"); if(!in) { cerr << "Cannot open file data.ini.\n"; return -1; } P = readPoints(in, dim); uint32_t N = P.size(); try { IStorageManager* memfile = StorageManager::createNewMemoryStorageManager(); StorageManager::IBuffer* file = StorageManager::createNewRandomEvictionsBuffer(*memfile, 10, false); id_type indexIdentifier; ISpatialIndex* tree = RTree::createNewRTree(*file, 0.7, CAPACITY, CAPACITY, dim, SpatialIndex::RTree::RV_RSTAR, indexIdentifier); id_type id = 0; for(uint32_t i = 0; i < N; ++i) { std::ostringstream os; os << P[i]; std::string data = os.str(); tree->insertData(data.size() + 1, reinterpret_cast<const byte*>(data.c_str()), P[i], id); id++; } /*std::cerr << "Operations: " << N << std::endl; std::cerr << *tree; std::cerr << "Buffer hits: " << file->getHits() << std::endl; std::cerr << "Index ID: " << indexIdentifier << std::endl; bool ret = tree->isIndexValid(); if (ret == false) std::cerr << "ERROR: Structure is invalid!" << std::endl; else std::cerr << "The stucture seems O.K." << std::endl; */ for(uint32_t loop = 1; loop <= LOOPNUM; ++loop) { cout << "/**************** BEGIN " << loop << " ***************/" << endl; /*generate query set*/ vector <Point> Q; //Q = genPoints(dim, n, area, loop); stringstream ss; ss << "../query/n" << n << "M" << area << "/loop" << loop; cout << ss.str().c_str() << endl; ifstream qin(ss.str().c_str()); if(!qin) { cerr << "Cannot open query file"; return -1; } Q = readPoints(qin, dim); /*************** BEGIN MQM method ******************/ MQM(tree, Q, n, FUN); // MQM method for finding ANN of Q /*************** END MQM method *******************/ /*************** BEGIN ADM method ******************/ CATCH cost1; cost1.catch_time(); vector <uint32_t> nnIDs = nearestNeighborSet(tree, Q, n); // find the NN for every qi in Q as qi' vector <Point> newQ; for(uint32_t i = 0; i < n; ++i) { newQ.push_back(P[nnIDs[i]]); } cost1.catch_time(); cout << "proposal method: cpu cost for finding NNs of Q as Q' is " << cost1.get_cost(2) << " millisecond(s)" << endl; /***** read dist-matrix index for Q' ********/ uint32_t maxK = P.size() / RATIO; // the length of dist-matrix index uint32_t * dmindex[n]; for(uint32_t i = 0; i < n; ++i) { // read the dist-matrix index of qi' dmindex[i] = readDMIndex(nnIDs[i], maxK); if (dmindex[i] == NULL) { cerr << "error for loading Dist-Matrix Index." << endl; return -1; } } double minadist = 0; /* ADM method for finding approxiamte ANN */ Point adm_ANN = ADM(newQ, n, P, N, dmindex, maxK, FUN, minadist, ERROR_RATE); cout << "ADM: best_dist is " << getAdist(adm_ANN, Q, n, FUN) << endl << endl; /*************** END ADM method *******************/ /*************** BEGIN approxiamte vp-ANN method ******************/ /* approximate vp-ANN method for finding ANN of Q'*/ CATCH cost2; cost2.catch_time(); Point centroid = findCentroid(Q, dim, n); minadist = getAdist(centroid, Q, n, FUN); uint32_t vpID = nearestNeighbor(tree, centroid); uint32_t best_id_Q = epsilonANN(Q, n, P, N, vpID, dmindex, maxK, FUN); cost2.catch_time(); cout << "approxiamte vp-ANN method: cpu cost is " << cost2.get_cost(2) << " millisecond(s)" << endl; cout << "approximate vp-ANN method: best_dist is " << getAdist(P[best_id_Q], Q, n, FUN) << endl; cout << "approxiamte vp-ANN method: best_NN is "; displayCoordinates(P[best_id_Q]); cout << endl; /*************** END approxiamte vp-ANN method *******************/ /*************** BEGIN BF MBM method ******************/ /* MBM method for finding ANN of Q */ CATCH mbmcost; mbmcost.catch_time(); Region M = getMBR(Q, dim, n); MyQueryStrategy qs = MyQueryStrategy(M, Q, FUN); tree->queryStrategy(qs); mbmcost.catch_time(); cout << "MBM: cpu cost is " << mbmcost.get_cost(2) << " millisecond(s)" << endl; cout << "MBM: best_dist is " << qs.best_dist << endl; cout << "MBM: best_NN is "; displayCoordinates(qs.best_NN); cout << "MBM: leafIO = " << qs.mbm_leafIO << "; indexIO = " << qs.mbm_indexIO << endl << endl; /*************** END BF MBM method *******************/ /*************** BEGIN brute method ******************/ /* brute method for finding ANN of Q*/ CATCH brute_cost; brute_cost.catch_time(); uint32_t ANNid = brute_ANN(Q, n, P, N, FUN); brute_cost.catch_time(); cout << "brute method: cpu cost is " << brute_cost.get_cost(2) << " millisecond(s)" << endl; double adist = getAdist(P[ANNid], Q, n, FUN); cout << "brute method: best_dist is " << adist << endl; cout << "brute method: best_NN is "; displayCoordinates(P[ANNid]); /*************** END brute method *******************/ cout << "/**************** END " << loop << " ****************/" << endl << endl; } // end loop delete tree; delete file; delete memfile; } catch(Tools::Exception& e) { cerr << "*********ERROR**********" << endl; std::string s = e.what(); cerr << s << endl; return -1; } catch(...) { cerr << "**********ERROR********" << endl; return -1; } return 1; }