void Map::generate(const unsigned int city_count, const unsigned int width, const unsigned int height, const unsigned int seed) { cities.resize(city_count); std::default_random_engine generator(seed); std::uniform_int_distribution<unsigned int> width_distribution(0, width); std::uniform_int_distribution<unsigned int> height_distribution(0, height); std::uniform_int_distribution<unsigned int> city_distribution(0, city_count - 1); for (size_t c = 0; c < city_count; c++) { cities[c].x = width_distribution(generator); cities[c].y = height_distribution(generator); } start = city_distribution(generator); end = city_distribution(generator); m_adaptor = MapAdaptor(cities); city_tree_t city_tree(2, m_adaptor, nanoflann::KDTreeSingleIndexAdaptorParams(10)); city_tree.buildIndex(); for (size_t c = 0; c < cities.size(); c++) { // Set index of city and generate connections cities[c].index = c; // Do we need this? // Consider 5 closest std::vector<size_t> ret_index(CITY_SEARCH + 1); std::vector<unsigned int>dist_sqr(CITY_SEARCH + 1); city_tree.knnSearch( &cities[c].x, CITY_SEARCH + 1, &ret_index[0], &dist_sqr[0]); for (size_t i = 1; i < ret_index.size(); i++) { // Do we include you or not? // Bernoulli, do your job buddy! std::bernoulli_distribution city_test_distribution(CITY_RATIO); if (city_test_distribution(generator)) { // Update our information cities[c].neighbors.insert( std::make_pair(ret_index[i], std::sqrt(dist_sqr[i]))); cities[ret_index[i]].neighbors.insert( std::make_pair(c, std::sqrt(dist_sqr[i]))); } } } }
void testNanoFLANN(CMesh& mesh, std::vector<unsigned int>& test_indeces, std::vector<vcg::Point3f> randomSamples) { std::cout << "==================================================="<< std::endl; std::cout << "nanoFLANN" << std::endl; PointCloud<float> cloud; cloud.pts.resize(mesh.vert.size()); for (size_t i=0; i < mesh.vert.size(); i++) { cloud.pts[i].x = mesh.vert[i].P().X(); cloud.pts[i].y = mesh.vert[i].P().Y(); cloud.pts[i].z = mesh.vert[i].P().Z(); } typedef nanoflann::KDTreeSingleIndexAdaptor< nanoflann::L2_Simple_Adaptor<float, PointCloud<float> > , PointCloud<float>, 3 /* dim */ > my_kd_tree_t; // Construction of the nanoFLANN KDtree QTime time; time.start(); my_kd_tree_t index(3, cloud, nanoflann::KDTreeSingleIndexAdaptorParams(16) ); index.buildIndex(); std::cout << "Build nanoFlann: " << time.elapsed() << " ms" << std::endl; // Test with the radius search std::cout << "Radius search (" << num_test << " tests)"<< std::endl; float avgTime = 0.0f; std::vector<std::pair<size_t,float> > ret_matches; nanoflann::SearchParams params; for (int ii = 0; ii < num_test; ii++) { time.restart(); const size_t nMatches = index.radiusSearch(mesh.vert[test_indeces[ii]].P().V(), queryDist, ret_matches, params); avgTime += time.elapsed(); } std::cout << "Time (radius = " << queryDist << "): " << avgTime << " ms (mean " << avgTime / num_test << "ms)" << std::endl; // Test with the k-nearest search std::cout << "k-Nearest search (" << num_test*10 << " tests)"<< std::endl; avgTime = 0.0f; std::vector<size_t> ret_index(kNearest); std::vector<float> out_dist_sqr(kNearest); for (int ii = 0; ii < num_test * 10; ii++) { time.restart(); index.knnSearch(mesh.vert[test_indeces[ii]].P().V(), kNearest, &ret_index[0], &out_dist_sqr[0]); avgTime += time.elapsed(); } std::cout << "Time (k = " << kNearest << "): " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl; // Test with the closest search std::cout << "Closest search (" << num_test*10 << " tests)"<< std::endl; avgTime = 0.0f; std::vector<size_t> ret_index_clos(1); std::vector<float> out_dist_sqr_clos(1); for (int ii = 0; ii < num_test * 10; ii++) { time.restart(); index.knnSearch(randomSamples[ii].V(), 1, &ret_index_clos[0], &out_dist_sqr_clos[0]); avgTime += time.elapsed(); } std::cout << "Time : " << avgTime << " ms (mean " << avgTime / (num_test * 10) << "ms)" << std::endl << std::endl; }
void InverseDistanceInterpolation<KDDim>::interpolate_field_data (const std::vector<std::string> &field_names, const std::vector<Point> &tgt_pts, std::vector<Number> &tgt_vals) const { libmesh_experimental(); // forcibly initialize, if needed #ifdef LIBMESH_HAVE_NANOFLANN if (_kd_tree.get() == NULL) const_cast<InverseDistanceInterpolation<KDDim>*>(this)->construct_kd_tree(); #endif START_LOG ("interpolate_field_data()", "InverseDistanceInterpolation<>"); libmesh_assert_equal_to (field_names.size(), this->n_field_variables()); // If we already have field variables, we assume we are appending. // that means the names and ordering better be identical! if (_names.size() != field_names.size()) { libMesh::err << "ERROR: when adding field data to an existing list the\n" << "varaible list must be the same!\n"; libmesh_error(); } for (unsigned int v=0; v<_names.size(); v++) if (_names[v] != field_names[v]) { libMesh::err << "ERROR: when adding field data to an existing list the\n" << "varaible list must be the same!\n"; libmesh_error(); } tgt_vals.resize (tgt_pts.size()*this->n_field_variables()); #ifdef LIBMESH_HAVE_NANOFLANN { std::vector<Number>::iterator out_it = tgt_vals.begin(); const size_t num_results = std::min((size_t) _n_interp_pts, _src_pts.size()); std::vector<size_t> ret_index(num_results); std::vector<Real> ret_dist_sqr(num_results); for (std::vector<Point>::const_iterator tgt_it=tgt_pts.begin(); tgt_it != tgt_pts.end(); ++tgt_it) { const Point &tgt(*tgt_it); const Real query_pt[] = { tgt(0), tgt(1), tgt(2) }; _kd_tree->knnSearch(&query_pt[0], num_results, &ret_index[0], &ret_dist_sqr[0]); this->interpolate (tgt, ret_index, ret_dist_sqr, out_it); // libMesh::out << "knnSearch(): num_results=" << num_results << "\n"; // for (size_t i=0;i<num_results;i++) // libMesh::out << "idx[" << i << "]=" // << std::setw(6) << ret_index[i] // << "\t dist["<< i << "]=" << ret_dist_sqr[i] // << "\t val[" << std::setw(6) << ret_index[i] << "]=" << _src_vals[ret_index[i]] // << std::endl; // libMesh::out << "\n"; // libMesh::out << "ival=" << _vals[0] << '\n'; } } #else libMesh::err << "ERROR: This functionality requires the library to be configured\n" << "with nanoflann KD-Tree approximate nearest neighbor support!\n" << std::endl; libmesh_error(); #endif STOP_LOG ("interpolate_field_data()", "InverseDistanceInterpolation<>"); }