def test_load_ply_from_mesh_lab_with_vertex_colors(self):
self.mesh.request_vertex_colors()
options = openmesh.Options()
options += openmesh.Options.VertexColor
ok = openmesh.read_mesh(self.mesh, "meshlab.ply", options)
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_faces(), 12)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
self.assertFalse(options.vertex_has_normal())
self.assertFalse(options.vertex_has_texcoord())
self.assertTrue(options.vertex_has_color())
self.mesh.release_vertex_colors()
def test_load_simple_ply_with_texcoords(self):
self.mesh.request_vertex_texcoords2D()
options = openmesh.Options()
options += openmesh.Options.VertexTexCoord
ok = openmesh.read_mesh(self.mesh, "cube-minimal-texCoords.ply", options)
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_faces(), 12)
self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(0))[0], 10.0)
self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(0))[1], 10.0)
self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(2))[0], 6.0)
self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(2))[1], 6.0)
self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(4))[0], 9.0)
self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(4))[1], 9.0)
self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(7))[0], 12.0)
self.assertEqual(self.mesh.texcoord2D(self.mesh.vertex_handle(7))[1], 12.0)
self.assertFalse(options.vertex_has_normal())
self.assertTrue(options.vertex_has_texcoord())
self.assertFalse(options.vertex_has_color())
self.mesh.release_vertex_texcoords2D()
def test_load_simple_ply_with_normals(self):
self.mesh.request_vertex_normals()
options = openmesh.Options()
options += openmesh.Options.VertexNormal
ok = openmesh.read_mesh(self.mesh, "cube-minimal-normals.ply", options)
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_faces(), 12)
self.assertTrue(options.vertex_has_normal())
self.assertFalse(options.vertex_has_texcoord())
self.assertFalse(options.vertex_has_color())
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(0))[0], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(0))[1], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(0))[2], 1.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(3))[0], 1.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(3))[1], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(3))[2], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(4))[0], 1.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(4))[1], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(4))[2], 1.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(7))[0], 1.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(7))[1], 1.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(7))[2], 2.0)
self.mesh.release_vertex_normals()
def test_load_simple_obj_with_vertex_colors_as_vc_lines(self):
self.mesh.request_vertex_colors()
options = openmesh.Options()
options += openmesh.Options.VertexColor
file_name = "cube-minimal-vertex-colors-as-vc-lines.obj"
ok = openmesh.read_mesh(self.mesh, file_name, options)
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_faces(), 12)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
self.mesh.release_vertex_colors()
def read_obj(filename):
mesh = OM.TriMesh()
options = OM.Options()
ok = OM.read_mesh(mesh, filename, options)
mesh.request_face_normals()
mesh.update_face_normals()
if not ok:
raise RuntimeError('read_obj() failed to read file: ' + filename)
return mesh
def test_write_and_read_binary_float_vertex_colors_to_and_from_off_file(
self):
self.mesh.request_vertex_colors()
options = openmesh.Options(openmesh.Options.VertexColor)
ok = openmesh.read_mesh(self.mesh, "meshlab.ply", options)
self.assertTrue(ok)
options.clear()
options += openmesh.Options.VertexColor
options += openmesh.Options.Binary
options += openmesh.Options.ColorFloat
# Write the mesh
ok = openmesh.write_mesh(self.mesh, "cube_floating_binary.off",
options)
self.assertTrue(ok)
self.mesh.clear()
options.clear()
options += openmesh.Options.VertexColor
options += openmesh.Options.Binary
options += openmesh.Options.ColorFloat
ok = openmesh.read_mesh(self.mesh, "cube_floating_binary.off", options)
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_faces(), 12)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
self.assertFalse(options.vertex_has_normal())
self.assertFalse(options.vertex_has_texcoord())
self.assertFalse(options.face_has_color())
self.assertTrue(options.vertex_has_color())
self.assertTrue(options.color_is_float())
self.assertTrue(options.is_binary())
self.mesh.release_vertex_colors()
def test_load_simple_obj_force_vertex_colors_although_not_available(self):
self.mesh.request_vertex_colors()
file_name = "cube-minimal.obj"
options = openmesh.Options()
options += openmesh.Options.VertexColor
ok = openmesh.read_mesh(self.mesh, file_name, options)
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_faces(), 12)
self.assertEqual(self.mesh.n_halfedges(), 36)
def test_write_and_read_binary_ply_with_float_vertex_colors(self):
self.mesh.request_vertex_colors()
options = openmesh.Options()
options += openmesh.Options.VertexColor
ok = openmesh.read_mesh(self.mesh, "meshlab.ply", options)
self.assertTrue(ok)
options += openmesh.Options.ColorFloat
options += openmesh.Options.Binary
ok = openmesh.write_mesh(self.mesh, "meshlab_binary_float.ply", options)
self.assertTrue(ok)
self.mesh.clear
ok = openmesh.read_mesh(self.mesh, "meshlab_binary_float.ply", options)
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_faces(), 12)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(0))[2], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(3))[2], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(4))[2], 1.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[0], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[1], 0.0)
self.assertEqual(self.mesh.color(self.mesh.vertex_handle(7))[2], 1.0)
self.assertFalse(options.vertex_has_normal())
self.assertFalse(options.vertex_has_texcoord())
self.assertTrue(options.vertex_has_color())
self.assertTrue(options.color_is_float())
self.assertTrue(options.is_binary())
self.mesh.release_vertex_colors()
def test_load_simple_stl_file_with_normals(self):
self.mesh.request_face_normals()
options = openmesh.Options()
options += openmesh.Options.FaceNormal
ok = openmesh.read_mesh(self.mesh, "cube1.stl", options)
self.assertTrue(ok)
self.assertAlmostEqual(self.mesh.normal(self.mesh.face_handle(0))[0], -0.038545)
self.assertAlmostEqual(self.mesh.normal(self.mesh.face_handle(0))[1], -0.004330)
self.assertAlmostEqual(self.mesh.normal(self.mesh.face_handle(0))[2], 0.999247)
self.assertEqual(self.mesh.n_vertices(), 7526)
self.assertEqual(self.mesh.n_edges(), 22572)
self.assertEqual(self.mesh.n_faces(), 15048)
self.mesh.release_face_normals()
def test_load_simple_obj_check_texcoords(self):
self.mesh.request_halfedge_texcoords2D()
options = openmesh.Options()
options += openmesh.Options.FaceTexCoord
file_name = "cube-minimal-texCoords.obj"
ok = openmesh.read_mesh(self.mesh, file_name, options)
self.assertTrue(ok)
self.assertEqual(
self.mesh.texcoord2D(self.mesh.halfedge_handle(0))[0], 1.0)
self.assertEqual(
self.mesh.texcoord2D(self.mesh.halfedge_handle(0))[1], 1.0)
self.assertEqual(
self.mesh.texcoord2D(self.mesh.halfedge_handle(10))[0], 3.0)
self.assertEqual(
self.mesh.texcoord2D(self.mesh.halfedge_handle(10))[1], 3.0)
self.assertEqual(
self.mesh.texcoord2D(self.mesh.halfedge_handle(19))[0], 6.0)
self.assertEqual(
self.mesh.texcoord2D(self.mesh.halfedge_handle(19))[1], 6.0)
self.assertEqual(
self.mesh.texcoord2D(self.mesh.halfedge_handle(24))[0], 7.0)
self.assertEqual(
self.mesh.texcoord2D(self.mesh.halfedge_handle(24))[1], 7.0)
self.assertEqual(
self.mesh.texcoord2D(self.mesh.halfedge_handle(30))[0], 9.0)
self.assertEqual(
self.mesh.texcoord2D(self.mesh.halfedge_handle(30))[1], 9.0)
self.assertEqual(
self.mesh.texcoord2D(self.mesh.halfedge_handle(35))[0], 12.0)
self.assertEqual(
self.mesh.texcoord2D(self.mesh.halfedge_handle(35))[1], 12.0)
self.mesh.release_halfedge_texcoords2D()
def test_write_and_read_vertex_colors_to_and_from_off_file(self):
self.mesh.request_vertex_colors()
self.mesh.add_vertex(openmesh.Vec3d(0, 0, 1))
self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0))
self.mesh.add_vertex(openmesh.Vec3d(0, 1, 1))
self.mesh.add_vertex(openmesh.Vec3d(1, 0, 1))
# Using the default openmesh Python color type
testColor = openmesh.Vec4f(1.0, 0.5, 0.25, 1.0)
# Setting colors (different from black)
for v in self.mesh.vertices():
self.mesh.set_color(v, testColor)
# Check if the colors are correctly set
count = 0
for v in self.mesh.vertices():
color = self.mesh.color(v)
if color[0] != testColor[0] or color[1] != testColor[1] or color[
2] != testColor[2]:
count += 1
self.assertEqual(count, 0)
options = openmesh.Options()
options += openmesh.Options.VertexColor
options += openmesh.Options.ColorFloat
openmesh.write_mesh(self.mesh, "temp.off", options)
openmesh.read_mesh(self.mesh, "temp.off", options)
# Check if vertices still have the same color
count = 0
for v in self.mesh.vertices():
color = self.mesh.color(v)
if color[0] != testColor[0] or color[1] != testColor[1] or color[
2] != testColor[2]:
count += 1
self.assertEqual(count, 0)
self.mesh.release_vertex_colors()
def test_load_obj_with_material(self):
self.mesh.request_face_colors()
options = openmesh.Options()
options += openmesh.Options.FaceColor
file_name = "square_material.obj"
ok = openmesh.read_mesh(self.mesh, file_name, options)
self.assertTrue(ok)
fh = self.mesh.face_handle(self.mesh.halfedge_handle(0))
self.assertTrue(fh.is_valid())
self.assertAlmostEqual(self.mesh.color(fh)[0], 0.5, 2)
self.assertAlmostEqual(self.mesh.color(fh)[1], 0.5, 2)
self.assertAlmostEqual(self.mesh.color(fh)[2], 0.5, 2)
self.mesh.release_face_colors()
def test_write_triangle_vertex_integer_color(self):
self.mesh.request_vertex_colors()
options = openmesh.Options()
options += openmesh.Options.VertexColor
options += openmesh.Options.ColorFloat
filename = "triangle-minimal-ColorsPerVertex.om"
# Generate data
v1 = self.mesh.add_vertex(openmesh.Vec3d(1.0, 0.0, 0.0))
v2 = self.mesh.add_vertex(openmesh.Vec3d(0.0, 1.0, 0.0))
v3 = self.mesh.add_vertex(openmesh.Vec3d(0.0, 0.0, 1.0))
self.mesh.add_face(v1, v2, v3)
c1 = openmesh.Vec4f(0.00, 0.00, 0.50, 1.00)
c2 = openmesh.Vec4f(0.25, 0.00, 0.00, 1.00)
c3 = openmesh.Vec4f(0.00, 0.75, 0.00, 1.00)
self.mesh.set_color(v1, c1)
self.mesh.set_color(v2, c2)
self.mesh.set_color(v3, c3)
# Save
ok = openmesh.write_mesh(self.mesh, filename, options)
self.assertTrue(ok)
self.mesh.release_vertex_colors()
# Load
cmpMesh = openmesh.TriMesh()
cmpMesh.request_vertex_colors()
ok = openmesh.read_mesh(cmpMesh, filename, options)
self.assertTrue(ok)
self.assertTrue(cmpMesh.has_vertex_colors())
# Compare
self.assertEqual(self.mesh.n_vertices(), 3)
self.assertEqual(self.mesh.n_edges(), 3)
self.assertEqual(self.mesh.n_faces(), 1)
self.assertEqual(cmpMesh.point(v1), openmesh.Vec3d(1.0, 0.0, 0.0))
self.assertEqual(cmpMesh.point(v2), openmesh.Vec3d(0.0, 1.0, 0.0))
self.assertEqual(cmpMesh.point(v3), openmesh.Vec3d(0.0, 0.0, 1.0))
self.assertAlmostEqual(cmpMesh.color(v1)[0], c1[0], 2)
self.assertAlmostEqual(cmpMesh.color(v1)[1], c1[1], 2)
self.assertAlmostEqual(cmpMesh.color(v1)[2], c1[2], 2)
self.assertAlmostEqual(cmpMesh.color(v1)[3], c1[3], 2)
self.assertAlmostEqual(cmpMesh.color(v2)[0], c2[0], 2)
self.assertAlmostEqual(cmpMesh.color(v2)[1], c2[1], 2)
self.assertAlmostEqual(cmpMesh.color(v2)[2], c2[2], 2)
self.assertAlmostEqual(cmpMesh.color(v2)[3], c2[3], 2)
self.assertAlmostEqual(cmpMesh.color(v3)[0], c3[0], 2)
self.assertAlmostEqual(cmpMesh.color(v3)[1], c3[1], 2)
self.assertAlmostEqual(cmpMesh.color(v3)[2], c3[2], 2)
self.assertAlmostEqual(cmpMesh.color(v3)[3], c3[3], 2)
# Clean up
cmpMesh.release_vertex_colors()
os.remove(filename)
def test_load_simple_obj_check_halfedge_and_vertex_normals(self):
self.mesh.request_halfedge_normals()
self.mesh.request_vertex_normals()
options = openmesh.Options()
options += openmesh.Options.VertexNormal
file_name = "cube-minimal.obj"
ok = openmesh.read_mesh(self.mesh, file_name, options)
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_faces(), 12)
self.assertEqual(self.mesh.n_halfedges(), 36)
# =====================================================
# Check vertex normals
# =====================================================
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(0))[0], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(0))[1], -1.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(0))[2], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(3))[0], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(3))[1], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(3))[2], 1.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(4))[0], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(4))[1], -1.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(4))[2], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(7))[0], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(7))[1], 0.0)
self.assertEqual(self.mesh.normal(self.mesh.vertex_handle(7))[2], 1.0)
# =====================================================
# Check halfedge normals
# =====================================================
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(0))[0], 0.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(0))[1], 0.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(0))[2], -1.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(10))[0], -1.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(10))[1], 0.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(10))[2], 0.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(19))[0], 0.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(19))[1], 1.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(19))[2], 0.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(24))[0], 1.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(24))[1], 0.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(24))[2], 0.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(30))[0], 0.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(30))[1], -1.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(30))[2], 0.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(35))[0], 0.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(35))[1], 0.0)
self.assertEqual(
self.mesh.normal(self.mesh.halfedge_handle(35))[2], 1.0)
self.mesh.release_vertex_normals()
self.mesh.release_halfedge_normals()
