void process_input(struct partition_op &partop) { // build in memory Tree VecStreamReader vecstream(&vec); IStorageManager* memoryFile = StorageManager::createNewMemoryStorageManager(); id_type indexIdentifier = 0; ISpatialIndex* tree = RTree::createAndBulkLoadNewRTree(RTree::BLM_STR, vecstream, *memoryFile, fillFactor, indexCapacity, partop.bucket_size, 2, SpatialIndex::RTree::RV_RSTAR, indexIdentifier); // Traverse through each leaf node which is a partition MyQueryStrategy qs(&partop); tree->queryStrategy(qs); #ifdef DEBUGAREA Rectangle *tmp; double span[2]; double area_total; for (int k = 0; k < 2; k++) { span[k] = partop.high[k] - partop.low[k]; } // Normalize the data for (vector<Rectangle*>::iterator it = list_rec.begin() ; it != list_rec.end(); ++it) { tmp = *it; tmp->low[0] = (tmp->low[0] - partop.low[0]) / span[0]; tmp->low[1] = (tmp->low[1] - partop.low[1]) / span[1]; tmp->high[0] = (tmp->high[0] - partop.low[0]) / span[0]; tmp->high[1] = (tmp->high[1] - partop.low[1]) / span[1]; area_total += (tmp->high[0] - tmp->low[0]) * (tmp->high[1] - tmp->low[1]); } cerr << "Area total: " << area_total << endl; if (list_rec.size() > 0) { cerr << "Area covered: " << findarea(list_rec) << endl; } for (vector<Rectangle*>::iterator it = list_rec.begin() ; it != list_rec.end(); ++it) { delete *it; } list_rec.clear(); #endif /* This will fail the code the Data is already removed by VecStreamReader for (vector<RTree::Data*>::iterator it = vec.begin() ; it != vec.end(); ++it) { delete *it; }*/ vec.clear(); delete tree; delete memoryFile; }
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; }
int main(int argc, char** argv) { uint32_t dim = 2; uint32_t n = 8; uint32_t N = 100; /*read static data set*/ vector <Point> P; P = genPoints(dim, N, 1, 0); // displayPset(P); 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++; } for(uint32_t loop = 1; loop <= LOOPNUM; ++loop) { cout << "/**************** BEGIN " << loop << " ***************/" << endl; /*generate query set*/ vector <Point> Q; Q = genPoints(dim, n, 1, loop); /*double pdata1[] = {0, 0}; double pdata2[] = {0, 1}; double pdata3[] = {1, 1}; Point q1(pdata1, dim), q2(pdata2, dim), q3(pdata3, dim); Q.push_back(q1); Q.push_back(q2); Q.push_back(q3); displayPset(Q); */ /*************** BEGIN BF MBM method ******************/ /* MBM method for finding ANN of Q */ CATCH mbmcost; mbmcost.catch_time(); Region M = getMBR(Q, dim, n); MyQueryStrategy qs(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 *******************/ 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; }
int main(int argc, const char * argv[]) { ParsePointFile(); try { string basename("RTREE.DATA"); IStorageManager *diskfile = StorageManager::loadDiskStorageManager(basename); StorageManager::IBuffer* file = StorageManager::createNewRandomEvictionsBuffer(*diskfile, 10, false); ISpatialIndex* tree = RTree::loadRTree(*file, 1); if (!tree->isIndexValid()) { cout << "Bad Tree" <<endl; return -1; } IStatistics *sts; tree->getStatistics(&sts); int MAX_LEVEL = dynamic_cast<RTree::Statistics*>(sts)->getTreeHeight(); //Operation on MBR in RTree level by level for (int m_level = 0; m_level < MAX_LEVEL; ++m_level) { LevelStrategy ls(m_level); tree->queryStrategy(ls); } delete sts; #ifdef DEBUG_TEST CheckStrategy cs; tree->queryStrategy(cs); #endif ////========== Start Multi-Treads ========================================= ////if the number of trajectories(points) is small, thread may be suspended boost::thread_group threads; for (int i=0; i<QUERY_SIZE; ++i) { threads.create_thread(boost::bind(&NN_RST::Put, rst_vector[i], dynamic_cast<RTree::RTree*>(tree))); } Taxi_Point p; double time; for (int i=0; i< QUERY_SIZE; ++i) { p = point_set[rst_vector[i]->Get()]; time = p.getMinimumDistance(*rst_vector[i]->query) / p.m_speed; Q.push(QEntry(i, p.traj_id, time)); } // No need to invoke AllCoverTest in every loop, so check_flag is set int check_flag=0; while(true) { QEntry entry = Q.top(); Q.pop(); p = point_set[rst_vector[entry.q_id]->Get()]; time = ComputePTime(p, *dynamic_cast<Point*>(rst_vector[entry.q_id]->query)); Q.push(QEntry(entry.q_id, p.traj_id, time)); if (!CTestHelper[entry.t_id].test(entry.q_id)) { if (Candidates.count(entry.t_id) == 0) Candidates[entry.t_id] = time; else Candidates[entry.t_id] += time; } // C.push_back(entry.t_id); if (CTestHelper.count(entry.t_id) == 0) { bitset<QUERY_SIZE> bt; bt.set(entry.q_id); CTestHelper[entry.t_id] = bt; } else { CTestHelper[entry.t_id].set(entry.q_id); } ++check_flag; if (check_flag > QUERY_K*100) { if (AllCoverTest()) break; else check_flag = 0; } } // set continued to false to stop all the other threads { boost::mutex::scoped_lock lock(bool_mutex); continued = false; } for (int i=0; i<QUERY_SIZE; ++i) rst_vector[i]->cond.notify_one(); threads.join_all(); //======= Multi-Threads are stopped ================================== // cout << Q.size() <<endl; // while (!Q.empty()) { // cout << Q.top().time<<endl; // Q.pop(); // } //===== Refine && Verification ===================================== double LargestK = -1.0; int LargestPos = -1; ComputeLargestK(LargestK, LargestPos); for (int traj_id : partial_covering) { double time = LowBound(traj_id); if (time < LargestK) { Candidates[LargestPos] = traj_id; ComputeLargestK(LargestK, LargestPos); } } // now all_covering is the final correct answer for(int traj_id : all_covering) cout << traj_id << endl; delete tree; delete file; delete diskfile; return 0; } catch (Tools::Exception& e) { cerr << "******ERROR******" << endl; std::string s = e.what(); cerr << s << endl; return -1; } catch (...) { cerr << "******ERROR******" << endl; cerr << "other exception" << endl; return -1; } }