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_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 makeDrainMeshPaths(path, tolerance, cpus):
import openmesh as om
mesh = om.PolyMesh()
om.read_mesh(mesh, path)
drainCurves = drainMeshPaths(mesh, tolerance, cpus)
outfile = r'C:\Users\Christian\Desktop\drainCurves.obj'
result = om.write_mesh(drainCurves, outfile)
if result:
return True
else:
return False
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 Decimate_mesh(meshvtk,name_vtkmesh,nvertices=2000):
print 'test'
stlWriter = vtk.vtkSTLWriter()
stlWriter.SetFileName('meshdecimated.stl')
stlWriter.SetInputData(meshvtk)
stlWriter.Write()
mesh_om = om.PolyMesh()
Result=om.read_mesh(mesh_om, "meshdecimated.stl")
print Result
deci_om=om.PolyMeshDecimater(mesh_om)
mh=om.PolyMeshModQuadricHandle()
deci_om.add(mh)
deci_om.initialize()
deci_om.decimate_to(nvertices)
mesh_om.garbage_collection()
assert mesh_om.n_vertices()==nvertices, 'vertices goal not acomplished; nvertices={0:d}'.format(mesh_om.n_vertices())
print "Decimation to {0} vertices Sucessful".format(nvertices)
om.write_mesh(mesh_om,'meshdecimated.stl')
stlReader = vtk.vtkSTLReader()
stlReader.SetFileName('meshdecimated.stl')
stlReader.Update()
vtkwrite=vtk.vtkPolyDataWriter()
vtkwrite.SetInputData(stlReader.GetOutput())
vtkwrite.SetFileName(name_vtkmesh)
vtkwrite.Write()
print "enters"
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_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_triangle(self):
filename = "triangle-minimal.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)
# Save
ok = openmesh.write_mesh(self.mesh, filename)
self.assertTrue(ok)
# Reset
self.mesh.clear()
# Load
ok = openmesh.read_mesh(self.mesh, filename)
self.assertTrue(ok)
# Compare
self.assertEqual(self.mesh.n_vertices(), 3)
self.assertEqual(self.mesh.n_edges(), 3)
self.assertEqual(self.mesh.n_faces(), 1)
self.assertEqual(self.mesh.point(v1), openmesh.Vec3d(1.0, 0.0, 0.0))
self.assertEqual(self.mesh.point(v2), openmesh.Vec3d(0.0, 1.0, 0.0))
self.assertEqual(self.mesh.point(v3), openmesh.Vec3d(0.0, 0.0, 1.0))
# Cleanup
os.remove(filename)
def test_load_simple_om_with_vertex_colors(self):
self.mesh.request_vertex_colors()
options = openmesh.Options()
options += openmesh.Options.VertexColor
ok = openmesh.read_mesh(self.mesh, "cube-minimal-vertexColors.om", 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], 1.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], 1.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], 0.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_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 test_write_triangle(self):
filename = "triangle-minimal.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)
# Save
ok = openmesh.write_mesh(self.mesh, filename)
self.assertTrue(ok)
# Reset
self.mesh.clear()
# Load
ok = openmesh.read_mesh(self.mesh, filename)
self.assertTrue(ok)
# Compare
self.assertEqual(self.mesh.n_vertices(), 3)
self.assertEqual(self.mesh.n_edges(), 3)
self.assertEqual(self.mesh.n_faces(), 1)
self.assertEqual(self.mesh.point(v1), openmesh.Vec3d(1.0, 0.0, 0.0))
self.assertEqual(self.mesh.point(v2), openmesh.Vec3d(0.0, 1.0, 0.0))
self.assertEqual(self.mesh.point(v3), openmesh.Vec3d(0.0, 0.0, 1.0))
# Cleanup
os.remove(filename)
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 test_load_simple_om_with_texcoords(self):
self.mesh.request_vertex_texcoords2D()
options = openmesh.Options()
options += openmesh.Options.VertexTexCoord
ok = openmesh.read_mesh(self.mesh, "cube-minimal-texCoords.om", 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_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_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_point_ply_file_with_bad_encoding(self):
ok = openmesh.read_mesh(self.mesh, "pointCloudBadEncoding.ply")
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 10)
self.assertEqual(self.mesh.n_edges(), 0)
self.assertEqual(self.mesh.n_faces(), 0)
def test_load_simple_ply(self):
ok = openmesh.read_mesh(self.mesh, "cube-minimal.ply")
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_faces(), 12)
def test_load_simple_stl_file(self):
ok = openmesh.read_mesh(self.mesh, "cube1.stl")
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 7526)
self.assertEqual(self.mesh.n_edges(), 22572)
self.assertEqual(self.mesh.n_faces(), 15048)
def test_load_simple_point_ply_file_with_bad_encoding(self):
ok = openmesh.read_mesh(self.mesh, "pointCloudBadEncoding.ply")
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 10)
self.assertEqual(self.mesh.n_edges(), 0)
self.assertEqual(self.mesh.n_faces(), 0)
def test_load_simple_obj(self):
ok = openmesh.read_mesh(self.mesh, "cube-minimal.obj")
self.assertTrue(ok)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_faces(), 12)
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_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_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_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_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_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_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_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 calc_skel_radius(self, mesh_name=None, dim=3):
"""
calc nearest mesh vertex of skeleton vertex
"""
if mesh_name != None:
self.mesh_name = mesh_name
if self.mesh_name == None:
print 'please set mesh_name before calc_skel_radius'
elif os.path.isfile(self.mesh_name):
mesh = om.TriMesh()
assert om.read_mesh(mesh, self.mesh_name)
mesh_vertices = np.zeros((mesh.n_vertices(), dim), dtype=float)
for n, vh in enumerate(mesh.vertices()):
for i in xrange(3):
mesh_vertices[n, i] = mesh.point(vh)[i]
nbrs = NearestNeighbors(n_neighbors=1, algorithm='ball_tree').fit(mesh_vertices)
self.vert_radius, indices = nbrs.kneighbors(self.verts)
else:
print 'cannot find mesh file', self.mesh_name
sys.exit(0)
def read_obj(self, path):
mesh = openmesh.TriMesh()
openmesh.read_mesh(mesh, path)
return mesh
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()
if __name__ == '__main__':
inpath='/media/roger/48BCFC2BBCFC1562/dataset/labels_registered_mha/label_warped10.mha'
nvertices=2000
imgitk = sitk.ReadImage(inpath)
imgclean=clean_itkbin(imgitk,validlabel=2)
meshvtk=generate_mesh(imgclean)
_,_=compute_info_mesh(meshvtk)
WriteSTLMesh(meshvtk, 'meshdecimated.stl')
#===============================================================================
#
# This part should be in a function but it crashes duw to openmesh :/
#===============================================================================
mesh_om = om.PolyMesh()
Result=om.read_mesh(mesh_om, "meshdecimated.stl")
assert Result, "Open mesh could not read file"
deci_om=om.PolyMeshDecimater(mesh_om)
mh=om.PolyMeshModQuadricHandle()
deci_om.add(mh)
deci_om.initialize()
deci_om.decimate_to(nvertices)
mesh_om.garbage_collection()
assert mesh_om.n_vertices()==nvertices, 'vertices goal not acomplished; nvertices={0:d}'.format(mesh_om.n_vertices())
print "Decimation to {0} vertices Sucessful".format(nvertices)
om.write_mesh(mesh_om,'meshdecimated.stl')
################################################################################
meshvtktmp=LoadSTLMesh('meshdecimated.stl')
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()
