integration-of-complex-surfaces
/
ImplicitSurfaceNetwork
mirror of http://118.195.195.192:3000/ZCWang/ImplicitSurfaceNetwork.git
3
0
Fork 1
Code Issues Projects Releases Wiki Activity
Browse Source

fix tet build error

V2-integral
Zhicheng Wang 2 days ago
parent
db42b4c141
commit
3c6843b269
6 changed files with 81 additions and 96 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 78
      network_process/interface/fwd_types.hpp
  2. 9
      network_process/src/connect_by_topo/topology_ray_shooting.cpp
  3. 3
      network_process/src/network_process.cpp
  4. 45
      network_process/src/prim_gen/build_tetrahedron_and_adjacency.cpp
  5. 20
      network_process/src/prim_gen/extract_mesh.cpp
  6. 8
      network_process/src/prim_gen/extract_vertex_infos.cpp

78
network_process/interface/fwd_types.hpp
View File

@ -16,61 +16,55 @@ using pod_key_t = std::array<uint32_t, N>;
// ============================================================================== // ==============================================================================
struct scene_bg_mesh_info_t {
Eigen::Vector3d grid_offset{};
Eigen::Vector3d grid_size{};
Eigen::Vector3d grid_size_inv{};
Eigen::Vector<uint64_t, 3> vert_resolution{};
};
// x as the most significant bit, y as the second most significant bit, z as the least significant bit // x as the most significant bit, y as the second most significant bit, z as the least significant bit
static inline uint32_t hash_vert_pos(size_t x, size_t y, size_t z, const scene_bg_mesh_info_t& info) struct scene_bg_mesh_info_t {
{ void init(const aabb_t& aabb, uint32_t resolution)
return static_cast<uint32_t>(z + info.vert_resolution.z() * (y + info.vert_resolution.y() * x));
}
static inline uint32_t pos_hash_max(const scene_bg_mesh_info_t& info)
{ {
return hash_vert_pos(info.vert_resolution.x() - 1, info.vert_resolution.y() - 1, info.vert_resolution.z() - 1, info); this->grid_offset = aabb.min();
this->grid_size = aabb.sizes() / resolution;
this->vert_resolution = resolution + 1;
this->grid_resolution = resolution;
if (this->vert_resolution % 2 == 1) {
this->invert_hash_grid = [this](uint32_t hashed_value) {
auto y = (hashed_value / this->grid_resolution) % this->grid_resolution;
auto x = hashed_value / (this->grid_resolution * this->grid_resolution);
auto s = (x + y) & 1;
auto z = (hashed_value % this->grid_resolution) ^ s;
return std::array{x, y, z};
};
} else {
this->invert_hash_grid = [this](uint32_t hashed_value) {
auto z = hashed_value % this->grid_resolution;
auto y = (hashed_value / this->grid_resolution) % this->grid_resolution;
auto x = hashed_value / (this->grid_resolution * this->grid_resolution);
return std::array{x, y, z};
};
} }
static inline uint32_t hash_increment_x(uint32_t hashed_value, const scene_bg_mesh_info_t& info)
{
return hashed_value + static_cast<uint32_t>(info.vert_resolution.y() * info.vert_resolution.z());
} }
static inline uint32_t hash_increment_y(uint32_t hashed_value, const scene_bg_mesh_info_t& info) inline uint32_t hash_grid_pos(uint32_t x, uint32_t y, uint32_t z) const noexcept
{ {
return hashed_value + static_cast<uint32_t>(info.vert_resolution.z()); return z + this->vert_resolution * (y + this->vert_resolution * x);
} }
static inline uint32_t hash_increment_z(uint32_t hashed_value, const scene_bg_mesh_info_t& info) { return hashed_value + 1; } inline Eigen::Vector3d get_vert_pos(uint32_t hashed_value) const
static inline Eigen::Vector3d get_grid_pos(size_t x, size_t y, size_t z, const scene_bg_mesh_info_t& info)
{ {
return info.grid_offset + Eigen::Vector3d(x, y, z).cwiseProduct(info.grid_size); auto z = hashed_value % this->vert_resolution;
auto y = (hashed_value / this->vert_resolution) % this->vert_resolution;
auto x = hashed_value / (this->vert_resolution * this->vert_resolution);
return this->grid_offset + Eigen::Vector3d(x, y, z).cwiseProduct(this->grid_size);
} }
static inline Eigen::Vector3d get_grid_pos(const Eigen::Vector3d& pos, const scene_bg_mesh_info_t& info) uint32_t grid_count() const noexcept { return grid_resolution * grid_resolution * grid_resolution; }
{
return (pos - info.grid_offset).cwiseProduct(info.grid_size_inv);
}
static inline Eigen::Vector3d get_vert_pos(uint32_t hashed_value, const scene_bg_mesh_info_t& info) std::function<std::array<uint32_t, 3>(uint32_t)> invert_hash_grid{};
{
size_t z = static_cast<size_t>(hashed_value % (info.vert_resolution.z()));
size_t y = static_cast<size_t>((hashed_value / info.vert_resolution.z()) % info.vert_resolution.y());
size_t x = static_cast<size_t>(hashed_value / (info.vert_resolution.z() * info.vert_resolution.y()));
return get_grid_pos(x, y, z, info);
}
static inline std::array<size_t, 3> get_grid_pos(uint32_t hashed_value, const scene_bg_mesh_info_t& info) Eigen::Vector3d grid_offset{};
{ Eigen::Vector3d grid_size{};
size_t z = static_cast<size_t>(hashed_value % (info.vert_resolution.z())); uint32_t vert_resolution{};
size_t y = static_cast<size_t>((hashed_value / info.vert_resolution.z()) % info.vert_resolution.y()); uint32_t grid_resolution{};
size_t x = static_cast<size_t>(hashed_value / (info.vert_resolution.z() * info.vert_resolution.y())); };
return {x, y, z};
}
// ============================================================================== // ==============================================================================

9
network_process/src/connect_by_topo/topology_ray_shooting.cpp
View File

@ -72,8 +72,7 @@ struct equal_to<face_with_orient_t> {
// ============================================================================================ // ============================================================================================
void topo_ray_shooting(const scene_bg_mesh_info_t &scene_bg_mesh_info, void topo_ray_shooting(const std::vector<std::array<uint32_t, 4>> &tetrahedrons,
const std::vector<std::array<uint32_t, 4>> &tetrahedrons,
const flat_hash_map<uint32_t, uint32_t> &vertex_lexigraphical_adjacency, const flat_hash_map<uint32_t, uint32_t> &vertex_lexigraphical_adjacency,
const std::vector<arrangement_t> &tetrahedron_arrangements, const std::vector<arrangement_t> &tetrahedron_arrangements,
const std::vector<iso_vertex_t> &iso_verts, const std::vector<iso_vertex_t> &iso_verts,
@ -95,8 +94,7 @@ void topo_ray_shooting(const scene_bg_mesh_info_t &scene_bg_mesh
flat_hash_map<face_header_t, uint32_t> iso_face_id_of_tet_face{}; flat_hash_map<face_header_t, uint32_t> iso_face_id_of_tet_face{};
// map: (tet_id, tet_vert_id) --> (iso_vert_id, component_id) // map: (tet_id, tet_vert_id) --> (iso_vert_id, component_id)
flat_hash_map<simplified_vertex_header_t, component_header_t> iso_vId_compId_of_tet_vert{}; flat_hash_map<simplified_vertex_header_t, component_header_t> iso_vId_compId_of_tet_vert{};
find_extremal_edges(scene_bg_mesh_info, find_extremal_edges(iso_verts,
iso_verts,
iso_faces, iso_faces,
patches, patches,
components, components,
@ -215,8 +213,7 @@ void topo_ray_shooting(const scene_bg_mesh_info_t &scene_bg_mesh
} }
} }
void find_extremal_edges(const scene_bg_mesh_info_t &scene_bg_mesh_info, void find_extremal_edges(const std::vector<iso_vertex_t> &iso_verts,
const std::vector<iso_vertex_t> &iso_verts,
const std::vector<polygon_face_t> &iso_faces, const std::vector<polygon_face_t> &iso_faces,
const std::vector<std::vector<uint32_t>> &patches, const std::vector<std::vector<uint32_t>> &patches,
const std::vector<std::vector<uint32_t>> &components, const std::vector<std::vector<uint32_t>> &components,

3
network_process/src/network_process.cpp
View File

@ -253,8 +253,7 @@ ISNP_API void build_implicit_network_by_blobtree(const s_settings& s
} else { } else {
{ {
std::vector<std::pair<uint32_t, uint32_t>> shell_links{}; std::vector<std::pair<uint32_t, uint32_t>> shell_links{};
topo_ray_shooting(scene_bg_mesh_info, topo_ray_shooting(tetrahedrons,
tetrahedrons,
vertex_lexigraphical_adjacency, vertex_lexigraphical_adjacency,
tetrahedron_arrangements, tetrahedron_arrangements,
iso_verts, iso_verts,

45
network_process/src/prim_gen/build_tetrahedron_and_adjacency.cpp
View File

@ -21,9 +21,8 @@ void build_tetrahedron_and_adjacency(const scene_bg_mesh_info_t&
flat_hash_map<uint32_t, std::vector<uint32_t>>& reverse_vertex_adjacency, flat_hash_map<uint32_t, std::vector<uint32_t>>& reverse_vertex_adjacency,
btree_map<uint32_t, std::vector<uint32_t>>& vertex_to_tet_mapping) btree_map<uint32_t, std::vector<uint32_t>>& vertex_to_tet_mapping)
{ {
scene_bg_mesh_info_t culled_scene_bg_mesh_info = scene_bg_mesh_info; auto res = scene_bg_mesh_info.grid_resolution - 1;
culled_scene_bg_mesh_info.vert_resolution -= Eigen::Vector<uint64_t, 3>::Ones(); tetrahedrons.reserve(res * res * res * 5);
tetrahedrons.reserve((culled_scene_bg_mesh_info.vert_resolution.array() - 1).prod() * 5);
auto insert_or_compare_vertex_adjacency = [&](uint32_t src, uint32_t dst) { auto insert_or_compare_vertex_adjacency = [&](uint32_t src, uint32_t dst) {
reverse_vertex_adjacency[dst].reserve(reverse_vertex_adjacency[dst].size() + 3); reverse_vertex_adjacency[dst].reserve(reverse_vertex_adjacency[dst].size() + 3);
@ -32,16 +31,16 @@ void build_tetrahedron_and_adjacency(const scene_bg_mesh_info_t&
reverse_vertex_adjacency[dst].emplace_back(src); reverse_vertex_adjacency[dst].emplace_back(src);
}; };
for (size_t i = 0; i < pos_hash_max(culled_scene_bg_mesh_info); i += 2) { for (size_t i = 0; i < scene_bg_mesh_info.grid_count(); i += 2) {
auto [x, y, z] = get_grid_pos(i, culled_scene_bg_mesh_info); auto [x, y, z] = scene_bg_mesh_info.invert_hash_grid(i);
auto v0 = hash_vert_pos(x, y, z, scene_bg_mesh_info); auto v0 = scene_bg_mesh_info.hash_grid_pos(x, y, z);
auto v1 = hash_increment_x(v0, scene_bg_mesh_info); // +yz auto v1 = scene_bg_mesh_info.hash_grid_pos(x + 1, y, z);
auto v2 = hash_increment_y(v1, scene_bg_mesh_info); // +yz+z auto v2 = scene_bg_mesh_info.hash_grid_pos(x + 1, y + 1, z);
auto v3 = hash_increment_y(v0, scene_bg_mesh_info); // +z auto v3 = scene_bg_mesh_info.hash_grid_pos(x, y + 1, z);
auto v4 = hash_increment_z(v0, scene_bg_mesh_info); // +1 auto v4 = scene_bg_mesh_info.hash_grid_pos(x, y, z + 1);
auto v5 = hash_increment_x(v4, scene_bg_mesh_info); // +yz+1 auto v5 = scene_bg_mesh_info.hash_grid_pos(x + 1, y, z + 1);
auto v6 = hash_increment_y(v5, scene_bg_mesh_info); // +yz+z+1 auto v6 = scene_bg_mesh_info.hash_grid_pos(x + 1, y + 1, z + 1);
auto v7 = hash_increment_y(v4, scene_bg_mesh_info); // +z+1 auto v7 = scene_bg_mesh_info.hash_grid_pos(x, y + 1, z + 1);
// vertex lexigraphical ordering: v0, v4, v3, v1, v7, v5, v2, v6 // vertex lexigraphical ordering: v0, v4, v3, v1, v7, v5, v2, v6
tetrahedrons.emplace_back(std::array{v4, v3, v1, v6}); tetrahedrons.emplace_back(std::array{v4, v3, v1, v6});
@ -59,16 +58,16 @@ void build_tetrahedron_and_adjacency(const scene_bg_mesh_info_t&
insert_or_compare_vertex_adjacency(v7, v4); insert_or_compare_vertex_adjacency(v7, v4);
} }
for (size_t i = 1; i < pos_hash_max(culled_scene_bg_mesh_info); i += 2) { for (size_t i = 1; i < scene_bg_mesh_info.grid_count(); i += 2) {
auto [x, y, z] = get_grid_pos(i, culled_scene_bg_mesh_info); auto [x, y, z] = scene_bg_mesh_info.invert_hash_grid(i);
auto v0 = hash_vert_pos(x, y, z, scene_bg_mesh_info); auto v0 = scene_bg_mesh_info.hash_grid_pos(x, y, z);
auto v1 = hash_increment_x(v0, scene_bg_mesh_info); auto v1 = scene_bg_mesh_info.hash_grid_pos(x + 1, y, z);
auto v2 = hash_increment_y(v1, scene_bg_mesh_info); auto v2 = scene_bg_mesh_info.hash_grid_pos(x + 1, y + 1, z);
auto v3 = hash_increment_y(v0, scene_bg_mesh_info); auto v3 = scene_bg_mesh_info.hash_grid_pos(x, y + 1, z);
auto v4 = hash_increment_z(v0, scene_bg_mesh_info); auto v4 = scene_bg_mesh_info.hash_grid_pos(x, y, z + 1);
auto v5 = hash_increment_x(v4, scene_bg_mesh_info); auto v5 = scene_bg_mesh_info.hash_grid_pos(x + 1, y, z + 1);
auto v6 = hash_increment_y(v5, scene_bg_mesh_info); auto v6 = scene_bg_mesh_info.hash_grid_pos(x + 1, y + 1, z + 1);
auto v7 = hash_increment_y(v4, scene_bg_mesh_info); auto v7 = scene_bg_mesh_info.hash_grid_pos(x, y + 1, z + 1);
// vertex lexigraphical ordering: v0, v4, v3, v1, v7, v5, v2, v6 // vertex lexigraphical ordering: v0, v4, v3, v1, v7, v5, v2, v6
tetrahedrons.emplace_back(std::array{v0, v7, v5, v2}); tetrahedrons.emplace_back(std::array{v0, v7, v5, v2});

20
network_process/src/prim_gen/extract_mesh.cpp
View File

@ -174,10 +174,10 @@ void extract_iso_mesh(const std::array<uint32_t, 3>& tet_active_sub
impl2[mapped_not_boundary_vIds[2]], impl2[mapped_not_boundary_vIds[2]],
impl2[mapped_not_boundary_vIds[3]]}; impl2[mapped_not_boundary_vIds[3]]};
const auto coord = compute_barycentric_coords(f1, f2, f3); const auto coord = compute_barycentric_coords(f1, f2, f3);
iso_pts.emplace_back(coord[0] * get_vert_pos(not_boundary_vIds[0], scene_bg_mesh_info) iso_pts.emplace_back(coord[0] * scene_bg_mesh_info.get_vert_pos(not_boundary_vIds[0])
+ coord[1] * get_vert_pos(not_boundary_vIds[1], scene_bg_mesh_info) + coord[1] * scene_bg_mesh_info.get_vert_pos(not_boundary_vIds[1])
+ coord[2] * get_vert_pos(not_boundary_vIds[2], scene_bg_mesh_info) + coord[2] * scene_bg_mesh_info.get_vert_pos(not_boundary_vIds[2])
+ coord[3] * get_vert_pos(not_boundary_vIds[3], scene_bg_mesh_info)); + coord[3] * scene_bg_mesh_info.get_vert_pos(not_boundary_vIds[3]));
} else if (num_boundary_planes == 1) { // on tet face } else if (num_boundary_planes == 1) { // on tet face
generate_new_iso_vert(vert_on_tetFace, [&] { generate_new_iso_vert(vert_on_tetFace, [&] {
const auto & impl0 = vertex_infos.col(implicit_pIds[0]), &impl1 = vertex_infos.col(implicit_pIds[1]); const auto & impl0 = vertex_infos.col(implicit_pIds[0]), &impl1 = vertex_infos.col(implicit_pIds[1]);
@ -188,21 +188,21 @@ void extract_iso_mesh(const std::array<uint32_t, 3>& tet_active_sub
impl1[mapped_not_boundary_vIds[1]], impl1[mapped_not_boundary_vIds[1]],
impl1[mapped_not_boundary_vIds[2]]}; impl1[mapped_not_boundary_vIds[2]]};
const auto coord = compute_barycentric_coords(f1, f2); const auto coord = compute_barycentric_coords(f1, f2);
iso_pts.emplace_back(coord[0] * get_vert_pos(not_boundary_vIds[0], scene_bg_mesh_info) iso_pts.emplace_back(coord[0] * scene_bg_mesh_info.get_vert_pos(not_boundary_vIds[0])
+ coord[1] * get_vert_pos(not_boundary_vIds[1], scene_bg_mesh_info) + coord[1] * scene_bg_mesh_info.get_vert_pos(not_boundary_vIds[1])
+ coord[2] * get_vert_pos(not_boundary_vIds[2], scene_bg_mesh_info)); + coord[2] * scene_bg_mesh_info.get_vert_pos(not_boundary_vIds[2]));
}); });
} else if (num_boundary_planes == 2) { // on tet edge } else if (num_boundary_planes == 2) { // on tet edge
generate_new_iso_vert(vert_on_tetEdge, [&] { generate_new_iso_vert(vert_on_tetEdge, [&] {
const auto f1 = vertex_infos(vertex_indices_mapping.at(not_boundary_vIds[0]), implicit_pIds[0]); const auto f1 = vertex_infos(vertex_indices_mapping.at(not_boundary_vIds[0]), implicit_pIds[0]);
const auto f2 = vertex_infos(vertex_indices_mapping.at(not_boundary_vIds[1]), implicit_pIds[0]); const auto f2 = vertex_infos(vertex_indices_mapping.at(not_boundary_vIds[1]), implicit_pIds[0]);
const auto coord = compute_barycentric_coords(f1, f2); const auto coord = compute_barycentric_coords(f1, f2);
iso_pts.emplace_back(coord[0] * get_vert_pos(not_boundary_vIds[0], scene_bg_mesh_info) iso_pts.emplace_back(coord[0] * scene_bg_mesh_info.get_vert_pos(not_boundary_vIds[0])
+ coord[1] * get_vert_pos(not_boundary_vIds[1], scene_bg_mesh_info)); + coord[1] * scene_bg_mesh_info.get_vert_pos(not_boundary_vIds[1]));
}); });
} else { // on tet vertex } else { // on tet vertex
generate_new_iso_vert(vert_on_tetVert, generate_new_iso_vert(vert_on_tetVert,
[&] { iso_pts.emplace_back(get_vert_pos(not_boundary_vIds[0], scene_bg_mesh_info)); }); [&] { iso_pts.emplace_back(scene_bg_mesh_info.get_vert_pos(not_boundary_vIds[0])); });
} }
} }
// create iso-faces // create iso-faces

8
network_process/src/prim_gen/extract_vertex_infos.cpp
View File

@ -26,11 +26,7 @@ void extract_vertex_infos(const s_settings& settings,
subface_active_vertices.resize(tree.subfaces.size()); subface_active_vertices.resize(tree.subfaces.size());
auto scene_aabb = mark_primitive_boundings(settings.scene_aabb_margin, tree, primitive_boundings); auto scene_aabb = mark_primitive_boundings(settings.scene_aabb_margin, tree, primitive_boundings);
scene_bg_mesh_info.init(scene_aabb, settings.resolution);
scene_bg_mesh_info.grid_offset = scene_aabb.min();
scene_bg_mesh_info.grid_size = scene_aabb.sizes() / settings.resolution;
scene_bg_mesh_info.grid_size_inv = scene_bg_mesh_info.grid_size.cwiseInverse();
scene_bg_mesh_info.vert_resolution = Eigen::Vector<uint64_t, 3>::Constant(settings.resolution + 1);
// compute the SDF values for each vertex // compute the SDF values for each vertex
for (uint32_t i = 0; i < tree.subfaces.size(); ++i) { for (uint32_t i = 0; i < tree.subfaces.size(); ++i) {
@ -39,7 +35,7 @@ void extract_vertex_infos(const s_settings& settings,
const auto subface_type = tree.subface_types[i]; const auto subface_type = tree.subface_types[i];
auto sdf_evaluator = std::bind(internal::get_eval_sdf_ptr(subface_type), subface_ptr, std::placeholders::_1); auto sdf_evaluator = std::bind(internal::get_eval_sdf_ptr(subface_type), subface_ptr, std::placeholders::_1);
for (uint32_t j = 0; j < subface_vert_info.size(); ++j) { for (uint32_t j = 0; j < subface_vert_info.size(); ++j) {
auto pos = get_vert_pos(j, scene_bg_mesh_info); auto pos = scene_bg_mesh_info.get_vert_pos(j);
subface_vert_info[j] = sdf_evaluator(pos); subface_vert_info[j] = sdf_evaluator(pos);
} }
} }

Write Preview
Loading…
Cancel
Save