C++ (Cpp) Map2::foreach_dart Examples

Example #1

File: bench_multithreading.cpp Project: etienneschmitt/CGoGN_2

static void BENCH_Dart_count_single_threaded(benchmark::State& state)
{
	while (state.KeepRunning())
	{
		unsigned nb_darts = 0u;
		bench_map.foreach_dart([&nb_darts] (cgogn::Dart) { nb_darts++; });
	}
}

Example #2

File: cmap2_import.cpp Project: untereiner/CGoGN_2

int main(int argc, char** argv)
{
	std::string surfaceMesh;
	if (argc < 2)
	{
		cgogn_log_info("cmap2_import") << "USAGE: " << argv[0] << " [filename]";
		surfaceMesh = std::string(DEFAULT_MESH_PATH) + std::string("off/aneurysm_3D.off");
		cgogn_log_info("cmap2_import") << "Using default mesh : " << surfaceMesh;
	}
	else
		surfaceMesh = std::string(argv[1]);

	Map2 map;

	for (uint32 k = 0; k < 2; ++k)
	{
		cgogn::io::import_surface<Vec3>(map, surfaceMesh);

		uint32 nb_darts = 0;
		map.foreach_dart([&nb_darts] (cgogn::Dart) { nb_darts++; });
		cgogn_log_info("cmap2_import") << "nb darts -> " << nb_darts;

		uint32 nb_darts_2 = 0;
		std::vector<uint32> nb_darts_per_thread(cgogn::NB_THREADS - 1);
		for (uint32& n : nb_darts_per_thread)
			n = 0;
		map.parallel_foreach_dart([&nb_darts_per_thread] (cgogn::Dart, uint32 thread_index)
		{
			nb_darts_per_thread[thread_index]++;
		});
		for (uint32 n : nb_darts_per_thread)
			nb_darts_2 += n;
		cgogn_log_info("cmap2_import")<< "nb darts // -> " << nb_darts_2;

		VertexAttribute<Vec3> vertex_position = map.get_attribute<Vec3, Map2::Vertex::ORBIT>("position");
		VertexAttribute<Vec3> vertex_normal = map.add_attribute<Vec3, Map2::Vertex::ORBIT>("normal");
		FaceAttribute<Vec3> face_normal = map.add_attribute<Vec3, Map2::Face::ORBIT>("normal");

		cgogn_log_info("cmap2_import")  << "Map integrity : " << std::boolalpha << map.check_map_integrity();

		uint32 nb_vertices = 0;
		cgogn::CellCache<Map2> cache(map);
		cache.build<Map2::Vertex>();
		map.foreach_cell([&nb_vertices] (Map2::Vertex) { nb_vertices++; }, cache);
		cgogn_log_info("cmap2_import") << "nb vertices -> " << nb_vertices;

		uint32 nb_boundary_faces = 0;
		cgogn::BoundaryCache<Map2> bcache(map);
		map.foreach_cell([&nb_boundary_faces] (Map2::Boundary) { nb_boundary_faces++; }, bcache);
		cgogn_log_info("cmap2_import") << "nb boundary faces -> " << nb_boundary_faces;

		uint32 nb_faces = 0;
		map.foreach_cell([&nb_faces] (Map2::Face) { nb_faces++;});
		cgogn_log_info("cmap2_import") << "nb faces -> " << nb_faces;

		uint32 nb_faces_2 = 0;
		std::vector<uint32> nb_faces_per_thread(cgogn::NB_THREADS - 1);
		for (uint32& n : nb_faces_per_thread)
			n = 0;
		map.parallel_foreach_cell([&nb_faces_per_thread] (Map2::Face, uint32 thread_index)
		{
			nb_faces_per_thread[thread_index]++;
		});
		for (uint32 n : nb_faces_per_thread)
			nb_faces_2 += n;
		cgogn_log_info("cmap2_import") << "nb faces // -> " << nb_faces_2;

		std::chrono::time_point<std::chrono::system_clock> start, end;
		start = std::chrono::system_clock::now();

		for	(uint32 i = 0; i < 10; ++i)
			cgogn::geometry::compute_normal<Vec3>(map, vertex_position, face_normal);

		for	(uint32 i = 0; i < 10; ++i)
			cgogn::geometry::compute_normal<Vec3>(map, vertex_position, vertex_normal);

		end = std::chrono::system_clock::now();
		std::chrono::duration<float64> elapsed_seconds = end - start;
		cgogn_log_info("cmap2_import") << "elapsed time: " << elapsed_seconds.count() << "s";
	}

	return 0;
}