From f6b106155f771758f1d363c95a9a044c6b73e1a6 Mon Sep 17 00:00:00 2001 From: Max Lyon Date: Fri, 12 Oct 2018 11:34:49 +0200 Subject: [PATCH] add unittests for writing and reading status information --- src/Unittests/unittests_read_write_OM.cc | 370 +++++++++++++++++++++++ 1 file changed, 370 insertions(+) diff --git a/src/Unittests/unittests_read_write_OM.cc b/src/Unittests/unittests_read_write_OM.cc index 899e86e5..92aaeed6 100644 --- a/src/Unittests/unittests_read_write_OM.cc +++ b/src/Unittests/unittests_read_write_OM.cc @@ -956,4 +956,374 @@ TEST_F(OpenMeshReadWriteOM, ReadBigMeshWithCustomProperty) { EXPECT_FALSE(wrong) << "min one vertex has worng vertex property"; } + +/* + * Save and load simple mesh with vertex status + */ +TEST_F(OpenMeshReadWriteOM, WriteReadStatusPropertyVertexOnly) { + + //read file + Mesh mesh; + auto vh0 = mesh.add_vertex(Mesh::Point(0,0,0)); + auto vh1 = mesh.add_vertex(Mesh::Point(1,0,0)); + auto vh2 = mesh.add_vertex(Mesh::Point(0,1,0)); + mesh.add_face(vh0, vh1, vh2); + + mesh.request_vertex_status(); + + mesh.status(vh0).set_selected(true); + mesh.status(vh1).set_feature(true); + mesh.status(vh2).set_tagged(true); + mesh.status(vh0).set_locked(true); + mesh.status(vh1).set_deleted(true); + mesh.status(vh2).set_hidden(true); + mesh.status(vh0).set_fixed_nonmanifold(true); + + + std::string filename_without_status = "no_vertex_status_test.om"; + std::string filename_with_status = "vertex_status_test.om"; + + OpenMesh::IO::Options opt_with_status = OpenMesh::IO::Options::Status; + OpenMesh::IO::write_mesh(mesh, filename_without_status); + OpenMesh::IO::write_mesh(mesh, filename_with_status, opt_with_status); + + // Load no status from file with status + { + Mesh loaded_mesh; + OpenMesh::IO::read_mesh(loaded_mesh, filename_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though they should not have been loaded"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though file should not have a stored status"; + } + + // Load status from file with status + { + Mesh loaded_mesh; + OpenMesh::IO::read_mesh(loaded_mesh, filename_with_status, opt_with_status); + + EXPECT_TRUE (loaded_mesh.has_vertex_status()) << "Mesh has no vertex status even though they should have been loaded"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though file should not have a stored status"; + + if (loaded_mesh.has_vertex_status()) + { + for (auto vh : mesh.vertices()) + { + EXPECT_EQ(mesh.status(vh).bits(), loaded_mesh.status(vh).bits()); + } + } + } + + // Load no status from file with status + { + Mesh loaded_mesh; + loaded_mesh.request_vertex_status(); + OpenMesh::IO::read_mesh(loaded_mesh, filename_with_status); + + EXPECT_TRUE (loaded_mesh.has_vertex_status()) << "Mesh vertex status was removed by reading"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though file should not have a stored status"; + + for (auto vh : loaded_mesh.vertices()) + { + EXPECT_EQ(loaded_mesh.status(vh).bits(), 0u) << "Vertex status was modified even though it should not have been loaded"; + } + } + + // Try to load status from file without status + { + Mesh loaded_mesh; + OpenMesh::IO::read_mesh(loaded_mesh, filename_without_status, opt_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though they file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though they file should not have a stored status"; + } +} + + +/* + * Save and load simple mesh with halfedge status + */ +TEST_F(OpenMeshReadWriteOM, WriteReadStatusPropertyHalfedgeOnly) { + + //read file + Mesh mesh; + auto vh0 = mesh.add_vertex(Mesh::Point(0,0,0)); + auto vh1 = mesh.add_vertex(Mesh::Point(1,0,0)); + auto vh2 = mesh.add_vertex(Mesh::Point(0,1,0)); + mesh.add_face(vh0, vh1, vh2); + + mesh.request_edge_status(); + + auto heh0 = OpenMesh::HalfedgeHandle(0); + auto heh1 = OpenMesh::HalfedgeHandle(1); + auto heh2 = OpenMesh::HalfedgeHandle(2); + auto heh3 = OpenMesh::HalfedgeHandle(3); + auto heh4 = OpenMesh::HalfedgeHandle(4); + auto heh5 = OpenMesh::HalfedgeHandle(5); + + mesh.status(heh0).set_selected(true); + mesh.status(heh1).set_feature(true); + mesh.status(heh2).set_tagged(true); + mesh.status(heh3).set_locked(true); + mesh.status(heh4).set_deleted(true); + mesh.status(heh5).set_hidden(true); + mesh.status(heh0).set_fixed_nonmanifold(true); + + std::string filename_without_status = "no_halfedge_status_test.om"; + std::string filename_with_status = "edge_halfstatus_test.om"; + + OpenMesh::IO::Options opt_with_status = OpenMesh::IO::Options::Status; + OpenMesh::IO::write_mesh(mesh, filename_without_status); + OpenMesh::IO::write_mesh(mesh, filename_with_status, opt_with_status); + + // Load no status from file with status + { + Mesh loaded_mesh; + OpenMesh::IO::read_mesh(loaded_mesh, filename_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though they should not have been loaded"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though file should not have a stored status"; + } + + // Load status from file with status + { + Mesh loaded_mesh; + OpenMesh::IO::read_mesh(loaded_mesh, filename_with_status, opt_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though they should have been loaded"; + EXPECT_TRUE(loaded_mesh.has_halfedge_status()) << "Mesh has no halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though file should not have a stored status"; + + if (loaded_mesh.has_halfedge_status()) + { + for (auto heh : mesh.halfedges()) + { + EXPECT_EQ(mesh.status(heh).bits(), loaded_mesh.status(heh).bits()); + } + } + } + + // Load no status from file with status + { + Mesh loaded_mesh; + loaded_mesh.request_halfedge_status(); + OpenMesh::IO::read_mesh(loaded_mesh, filename_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though file should not have a stored status"; + EXPECT_TRUE (loaded_mesh.has_halfedge_status()) << "Mesh halfedge status was removed by reading"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though file should not have a stored status"; + + for (auto heh : loaded_mesh.halfedges()) + { + EXPECT_EQ(loaded_mesh.status(heh).bits(), 0u) << "Edge status was modified even though it should not have been loaded"; + } + } + + // Try to load status from file without status + { + Mesh loaded_mesh; + OpenMesh::IO::read_mesh(loaded_mesh, filename_without_status, opt_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though they file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though they file should not have a stored status"; + } +} + + +/* + * Save and load simple mesh with edge status + */ +TEST_F(OpenMeshReadWriteOM, WriteReadStatusPropertyEdgeOnly) { + + //read file + Mesh mesh; + auto vh0 = mesh.add_vertex(Mesh::Point(0,0,0)); + auto vh1 = mesh.add_vertex(Mesh::Point(1,0,0)); + auto vh2 = mesh.add_vertex(Mesh::Point(0,1,0)); + mesh.add_face(vh0, vh1, vh2); + + mesh.request_edge_status(); + + auto eh0 = OpenMesh::EdgeHandle(0); + auto eh1 = OpenMesh::EdgeHandle(1); + auto eh2 = OpenMesh::EdgeHandle(2); + + mesh.status(eh0).set_selected(true); + mesh.status(eh1).set_feature(true); + mesh.status(eh2).set_tagged(true); + mesh.status(eh0).set_locked(true); + mesh.status(eh1).set_deleted(true); + mesh.status(eh2).set_hidden(true); + mesh.status(eh0).set_fixed_nonmanifold(true); + + std::string filename_without_status = "no_edge_status_test.om"; + std::string filename_with_status = "edge_status_test.om"; + + OpenMesh::IO::Options opt_with_status = OpenMesh::IO::Options::Status; + OpenMesh::IO::write_mesh(mesh, filename_without_status); + OpenMesh::IO::write_mesh(mesh, filename_with_status, opt_with_status); + + // Load no status from file with status + { + Mesh loaded_mesh; + OpenMesh::IO::read_mesh(loaded_mesh, filename_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though they should not have been loaded"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though file should not have a stored status"; + } + + // Load status from file with status + { + Mesh loaded_mesh; + OpenMesh::IO::read_mesh(loaded_mesh, filename_with_status, opt_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though they should have been loaded"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_TRUE(loaded_mesh.has_edge_status()) << "Mesh has no edge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though file should not have a stored status"; + + if (loaded_mesh.has_edge_status()) + { + for (auto eh : mesh.edges()) + { + EXPECT_EQ(mesh.status(eh).bits(), loaded_mesh.status(eh).bits()); + } + } + } + + // Load no status from file with status + { + Mesh loaded_mesh; + loaded_mesh.request_edge_status(); + OpenMesh::IO::read_mesh(loaded_mesh, filename_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_TRUE (loaded_mesh.has_edge_status()) << "Mesh edge status was removed by reading"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though file should not have a stored status"; + + for (auto eh : loaded_mesh.edges()) + { + EXPECT_EQ(loaded_mesh.status(eh).bits(), 0u) << "Edge status was modified even though it should not have been loaded"; + } + } + + // Try to load status from file without status + { + Mesh loaded_mesh; + OpenMesh::IO::read_mesh(loaded_mesh, filename_without_status, opt_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though they file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though they file should not have a stored status"; + } +} + + +/* + * Save and load simple mesh with face status + */ +TEST_F(OpenMeshReadWriteOM, WriteReadStatusPropertyFaceOnly) { + + //read file + Mesh mesh; + auto vh0 = mesh.add_vertex(Mesh::Point(0,0,0)); + auto vh1 = mesh.add_vertex(Mesh::Point(1,0,0)); + auto vh2 = mesh.add_vertex(Mesh::Point(0,1,0)); + auto vh3 = mesh.add_vertex(Mesh::Point(1,1,0)); + auto fh0 = mesh.add_face(vh0, vh1, vh2); + auto fh1 = mesh.add_face(vh2, vh1, vh3); + + mesh.request_face_status(); + + mesh.status(fh0).set_selected(true); + mesh.status(fh1).set_feature(true); + mesh.status(fh0).set_tagged(true); + mesh.status(fh1).set_locked(true); + mesh.status(fh0).set_deleted(true); + mesh.status(fh1).set_hidden(true); + mesh.status(fh0).set_fixed_nonmanifold(true); + + std::string filename_without_status = "no_face_status_test.om"; + std::string filename_with_status = "face_status_test.om"; + + OpenMesh::IO::Options opt_with_status = OpenMesh::IO::Options::Status; + OpenMesh::IO::write_mesh(mesh, filename_without_status); + OpenMesh::IO::write_mesh(mesh, filename_with_status, opt_with_status); + + // Load no status from file with status + { + Mesh loaded_mesh; + OpenMesh::IO::read_mesh(loaded_mesh, filename_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though they should not have been loaded"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though file should not have a stored status"; + } + + // Load status from file with status + { + Mesh loaded_mesh; + OpenMesh::IO::read_mesh(loaded_mesh, filename_with_status, opt_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though they should have been loaded"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though file should not have a stored status"; + EXPECT_TRUE(loaded_mesh.has_face_status()) << "Mesh has no face status even though file should not have a stored status"; + + if (loaded_mesh.has_face_status()) + { + for (auto fh : mesh.faces()) + { + EXPECT_EQ(mesh.status(fh).bits(), loaded_mesh.status(fh).bits()); + } + } + } + + // Load no status from file with status + { + Mesh loaded_mesh; + loaded_mesh.request_face_status(); + OpenMesh::IO::read_mesh(loaded_mesh, filename_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edgestatus even though file should not have a stored status"; + EXPECT_TRUE (loaded_mesh.has_face_status()) << "Mesh face status was removed by reading"; + + for (auto fh : loaded_mesh.faces()) + { + EXPECT_EQ(loaded_mesh.status(fh).bits(), 0u) << "Edge status was modified even though it should not have been loaded"; + } + } + + // Try to load status from file without status + { + Mesh loaded_mesh; + OpenMesh::IO::read_mesh(loaded_mesh, filename_without_status, opt_with_status); + + EXPECT_FALSE(loaded_mesh.has_vertex_status()) << "Mesh has vertex status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_halfedge_status()) << "Mesh has halfedge status even though file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_edge_status()) << "Mesh has edge status even though they file should not have a stored status"; + EXPECT_FALSE(loaded_mesh.has_face_status()) << "Mesh has face status even though they file should not have a stored status"; + } +} + }