diff --git a/network_process/src/prim_gen/extract_vertex_infos.cpp b/network_process/src/prim_gen/extract_vertex_infos.cpp index 2cc0c3e..c754e93 100644 --- a/network_process/src/prim_gen/extract_vertex_infos.cpp +++ b/network_process/src/prim_gen/extract_vertex_infos.cpp @@ -21,49 +21,10 @@ aabb_t mark_primitive_boundings(double aabb_margin, const baked_blobtree_t& tree return scene_aabb; } -void extract_active_subfaces(const s_settings& settings, - const baked_blobtree_t& tree, - const scene_bg_mesh_info_t& scene_bg_mesh_info, - const stl_vector_mp& primitive_boundings, - flat_hash_map_mp& vertex_infos, - stl_vector_mp>& subface_active_vertices, - stl_vector_mp& vertex_exist_regions) -{ - for (size_t i = 0; i < primitive_boundings.size(); ++i) { - const auto& primitive_aabb = primitive_boundings[i]; - auto& primitive = *tree.primitives[i].object_ptr; - - Eigen::Vector min_pos = - get_grid_pos(primitive_aabb.min(), scene_bg_mesh_info).array().floor().cast(); - Eigen::Vector max_pos = get_grid_pos(primitive_aabb.max(), scene_bg_mesh_info).array().ceil().cast(); - min_pos.array() = min_pos.array().max(0); - max_pos.array() = max_pos.array().min(settings.resolution); - vertex_exist_regions.emplace_back(min_pos, max_pos); - - // insert active faces of the primitive into the vertex_infos - // OPTIMIZE: the corner 4 vertices can be ignored - for (size_t x = min_pos.x(); x <= max_pos.x(); ++x) { - for (size_t y = min_pos.y(); y <= max_pos.y(); ++y) { - for (size_t z = min_pos.z(); z <= max_pos.z(); ++z) { - uint32_t hashed_value = hash_vert_pos(x, y, z, scene_bg_mesh_info); - auto& vertex_info = vertex_infos[hashed_value]; - vertex_info.reserve(tree.primitives[i].index_mapping.size()); - for (auto j : tree.primitives[i].index_mapping) { - auto& vert_face_info = vertex_info.emplace_back(); - vert_face_info.subface_index = j; - subface_active_vertices[j].emplace_back(hashed_value); - } - } - } - } - } -} - -void extract_vertex_infos(const s_settings& settings, - const baked_blobtree_t& tree, - scene_bg_mesh_info_t& scene_bg_mesh_info, - flat_hash_map_mp& vertex_infos, - stl_vector_mp& vertex_exist_regions) +void extract_vertex_infos(const s_settings& settings, + const baked_blobtree_t& tree, + scene_bg_mesh_info_t& scene_bg_mesh_info, + Eigen::MatrixXd& vertex_infos) { stl_vector_mp primitive_boundings{}; stl_vector_mp> subface_active_vertices{}; @@ -76,40 +37,16 @@ void extract_vertex_infos(const s_settings& setti scene_bg_mesh_info.grid_size_inv = scene_bg_mesh_info.grid_size.cwiseInverse(); scene_bg_mesh_info.vert_resolution = Eigen::Vector::Constant(settings.resolution + 1); - vertex_exist_regions.reserve(primitive_boundings.size()); - extract_active_subfaces(settings, - tree, - scene_bg_mesh_info, - primitive_boundings, - vertex_infos, - subface_active_vertices, - vertex_exist_regions); - - // remove duplicates in the active faces of each vertex - for (auto [_, vert_info] : vertex_infos) { - std::sort(vert_info.begin(), vert_info.end(), [&](const vert_face_info_t& lhs, const vert_face_info_t& rhs) { - return lhs.subface_index < rhs.subface_index; - }); - auto back_iter = std::unique(vert_info.begin(), vert_info.end()); - vert_info.erase(back_iter, vert_info.end()); - vert_info.shrink_to_fit(); - } - // compute the SDF values for each vertex - for (size_t i = 0; i < subface_active_vertices.size(); ++i) { - auto sdf_evaluator = tree.subfaces[i].object_ptr->fetch_sdf_evaluator(); - - for (auto hashed_value : subface_active_vertices[i]) { - auto pos = get_vert_pos(hashed_value, scene_bg_mesh_info); - auto& vertex_info = vertex_infos[hashed_value]; - - auto iter = std::lower_bound( - vertex_info.begin(), - vertex_info.end(), - i, - [](const vert_face_info_t& info, const size_t& face_index) { return info.subface_index < face_index; }); - iter->sdf_value = sdf_evaluator(pos); - iter->sdf_sign = sign_by_sdf(iter->sdf_value); + vertex_infos = + Eigen::MatrixXd::Zero(hash_vert_pos(settings.resolution, settings.resolution, settings.resolution, scene_bg_mesh_info), + tree.subfaces.size()); + for (uint32_t i = 0; i < tree.subfaces.size(); ++i) { + auto subface_vert_info = vertex_infos.col(i); + auto sdf_evaluator = tree.subfaces[i].object_ptr->fetch_sdf_evaluator(); + for (uint32_t j = 0; j < subface_vert_info.size(); ++j) { + auto pos = get_vert_pos(j, scene_bg_mesh_info); + subface_vert_info[j] = sdf_evaluator(pos); } } } \ No newline at end of file diff --git a/network_process/src/prim_gen/filter_tet_by_subface.cpp b/network_process/src/prim_gen/filter_tet_by_subface.cpp index 13d4a8e..7d916ed 100644 --- a/network_process/src/prim_gen/filter_tet_by_subface.cpp +++ b/network_process/src/prim_gen/filter_tet_by_subface.cpp @@ -1,7 +1,6 @@ #include #include -#include struct packed_sign_counter { uint8_t positive : 4; diff --git a/network_process/src/prim_gen/pair_tetrahedron.cpp b/network_process/src/prim_gen/pair_tetrahedron.cpp index 76e2f6a..f17ed9a 100644 --- a/network_process/src/prim_gen/pair_tetrahedron.cpp +++ b/network_process/src/prim_gen/pair_tetrahedron.cpp @@ -3,56 +3,46 @@ static constexpr uint64_t intertwined_01_bit_block = 0x5555555555555555; void pair_tetrahedron(const scene_bg_mesh_info_t& scene_bg_mesh_info, - const stl_vector_mp& vertex_exist_regions, stl_vector_mp>& tetrahedrons, flat_hash_map_mp>& vertex_to_tet_mapping) { - flat_hash_set_mp> tetrahedron_set{}; - tetrahedron_set.reserve(vertex_exist_regions.size() * 5); - - for (const auto& region : vertex_exist_regions) { - const auto& min_pos = region.first; - const auto& max_pos = region.second; - - for (size_t x = min_pos.x(); x < max_pos.x(); ++x) { - for (size_t y = min_pos.y(); y < max_pos.y(); ++y) { - for (size_t z = min_pos.z(); z < max_pos.z(); ++z) { - uint32_t v0 = hash_vert_pos(x, y, z, scene_bg_mesh_info); - uint32_t v1 = hash_vert_pos(x + 1, y, z, scene_bg_mesh_info); - uint32_t v2 = hash_vert_pos(x + 1, y + 1, z, scene_bg_mesh_info); - uint32_t v3 = hash_vert_pos(x, y + 1, z, scene_bg_mesh_info); - uint32_t v4 = hash_vert_pos(x, y, z + 1, scene_bg_mesh_info); - uint32_t v5 = hash_vert_pos(x + 1, y, z + 1, scene_bg_mesh_info); - uint32_t v6 = hash_vert_pos(x + 1, y + 1, z + 1, scene_bg_mesh_info); - uint32_t v7 = hash_vert_pos(x, y + 1, z + 1, scene_bg_mesh_info); - - if ((x + y + z) % 2 == 0) { - tetrahedron_set.insert({v4, v6, v1, v3}); - tetrahedron_set.insert({v6, v3, v4, v7}); - tetrahedron_set.insert({v1, v3, v0, v4}); - tetrahedron_set.insert({v3, v1, v2, v6}); - tetrahedron_set.insert({v4, v1, v6, v5}); - } else { - tetrahedron_set.insert({v7, v0, v2, v5}); - tetrahedron_set.insert({v2, v3, v0, v7}); - tetrahedron_set.insert({v5, v7, v0, v4}); - tetrahedron_set.insert({v7, v2, v6, v5}); - tetrahedron_set.insert({v0, v1, v2, v5}); - } + auto max_pos = scene_bg_mesh_info.vert_resolution.template cast() - Eigen::Vector::Ones(); + tetrahedrons.reserve((max_pos.array() - 1).prod() * 5); + + for (size_t x = 0; x < max_pos.x(); ++x) { + for (size_t y = 0; y < max_pos.y(); ++y) { + for (size_t z = 0; z < max_pos.z(); ++z) { + uint32_t v0 = hash_vert_pos(x, y, z, scene_bg_mesh_info); + uint32_t v1 = hash_vert_pos(x + 1, y, z, scene_bg_mesh_info); + uint32_t v2 = hash_vert_pos(x + 1, y + 1, z, scene_bg_mesh_info); + uint32_t v3 = hash_vert_pos(x, y + 1, z, scene_bg_mesh_info); + uint32_t v4 = hash_vert_pos(x, y, z + 1, scene_bg_mesh_info); + uint32_t v5 = hash_vert_pos(x + 1, y, z + 1, scene_bg_mesh_info); + uint32_t v6 = hash_vert_pos(x + 1, y + 1, z + 1, scene_bg_mesh_info); + uint32_t v7 = hash_vert_pos(x, y + 1, z + 1, scene_bg_mesh_info); + + if ((x + y + z) % 2 == 0) { + tetrahedrons.emplace_back(std::array{v4, v6, v1, v3}); + tetrahedrons.emplace_back(std::array{v6, v3, v4, v7}); + tetrahedrons.emplace_back(std::array{v1, v3, v0, v4}); + tetrahedrons.emplace_back(std::array{v3, v1, v2, v6}); + tetrahedrons.emplace_back(std::array{v4, v1, v6, v5}); + } else { + tetrahedrons.emplace_back(std::array{v7, v0, v2, v5}); + tetrahedrons.emplace_back(std::array{v2, v3, v0, v7}); + tetrahedrons.emplace_back(std::array{v5, v7, v0, v4}); + tetrahedrons.emplace_back(std::array{v7, v2, v6, v5}); + tetrahedrons.emplace_back(std::array{v0, v1, v2, v5}); } } } } - tetrahedrons.reserve(tetrahedron_set.size()); - for (const auto& tet : tetrahedron_set) { - auto tet_index = static_cast(tetrahedrons.size()); - tetrahedrons.emplace_back(tet); - - vertex_to_tet_mapping[tet[0]].emplace_back(tet_index); - vertex_to_tet_mapping[tet[1]].emplace_back(tet_index); - vertex_to_tet_mapping[tet[2]].emplace_back(tet_index); - vertex_to_tet_mapping[tet[3]].emplace_back(tet_index); + for (auto i = 0; i < tetrahedrons.size(); ++i) { + vertex_to_tet_mapping[tetrahedrons[i][0]].emplace_back(i); + vertex_to_tet_mapping[tetrahedrons[i][1]].emplace_back(i); + vertex_to_tet_mapping[tetrahedrons[i][2]].emplace_back(i); + vertex_to_tet_mapping[tetrahedrons[i][3]].emplace_back(i); } }