def test_vertex_iter(self):
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
# Add two faces
self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[0])
self.mesh.add_face(self.vhandle[2], self.vhandle[0], self.vhandle[3])
# Test setup:
# 1 === 2
# | / |
# | / |
# | / |
# 0 === 3
v_it = self.mesh.vertices()
self.assertEqual(v_it.__next__().idx(), 0)
self.assertEqual(v_it.__next__().idx(), 1)
self.assertEqual(v_it.__next__().idx(), 2)
self.assertEqual(v_it.__next__().idx(), 3)
self.assertRaises(StopIteration, v_it.__next__)
def test_add_quad_to_polymesh(self):
self.mesh = openmesh.PolyMesh()
self.vhandle = []
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
# Add one face
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[3])
self.mesh.add_face(face_vhandles)
# Test setup:
# 1 === 2
# | |
# | |
# | |
# 0 === 3
# Check setup
self.assertEqual(self.mesh.n_vertices(), 4)
self.assertEqual(self.mesh.n_faces(), 1)
def test_face_iter_empty_mesh_one_deleted_face(self):
# Request delete_face capability
self.mesh.request_vertex_status()
self.mesh.request_edge_status()
self.mesh.request_face_status()
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
# Add one face
fh = self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[0])
is_delete_isolated_vertex = False
self.mesh.delete_face(fh, is_delete_isolated_vertex)
# Test setup:
# 1 === 2
# | /
# | /
# | /
# 0
# Normal iterators
f_it = self.mesh.faces()
self.assertEqual(f_it.__next__().idx(), 0)
self.assertRaises(StopIteration, f_it.__next__)
# Same with skipping iterators
f_it = self.mesh.sfaces()
self.assertRaises(StopIteration, f_it.__next__)
def test_add_triangles_to_trimesh(self):
self.mesh = openmesh.TriMesh()
self.vhandle = []
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
# Add two faces
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[0])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[3])
self.mesh.add_face(face_vhandles)
# Test setup:
# 1 === 2
# | / |
# | / |
# | / |
# 0 === 3
# Check setup
self.assertEqual(self.mesh.n_vertices(), 4)
self.assertEqual(self.mesh.n_faces(), 2)
def test_check_status_properties_halfedge_edge_all_deleted(self):
self.mesh.request_vertex_status()
self.mesh.request_face_status()
self.mesh.request_halfedge_status()
self.mesh.request_edge_status()
# Define positions
p1 = openmesh.Vec3d(0, 0, 0)
p2 = openmesh.Vec3d(0, 1, 0)
p3 = openmesh.Vec3d(1, 1, 0)
p4 = openmesh.Vec3d(0, 0, 1)
# Add some vertices
vh1 = self.mesh.add_vertex(p1)
vh2 = self.mesh.add_vertex(p2)
vh3 = self.mesh.add_vertex(p3)
vh4 = self.mesh.add_vertex(p4)
# Add some faces
f1 = self.mesh.add_face(vh1, vh3, vh2)
f2 = self.mesh.add_face(vh1, vh2, vh4)
f3 = self.mesh.add_face(vh2, vh3, vh4)
f4 = self.mesh.add_face(vh3, vh1, vh4)
# Delete all faces
self.mesh.delete_face(f1)
self.mesh.delete_face(f2)
self.mesh.delete_face(f3)
self.mesh.delete_face(f4)
for heh in self.mesh.halfedges():
self.assertTrue(self.mesh.status(self.mesh.edge_handle(heh)).deleted())
self.assertTrue(self.mesh.status(heh).deleted())
def test_equality_operator_vec3d(self):
vec1 = openmesh.Vec3d(0.0, 1.0, 0.0)
vec2 = openmesh.Vec3d(1.0, 0.0, 0.0)
vec3 = openmesh.Vec3d(1.0, 0.0, 0.0)
self.assertFalse(vec1 == vec2)
self.assertTrue(vec3 == vec2)
def test_collapse_quad_with_center(self):
# 0--------1
# |\ /|
# | \ / |
# | \ / |
# | 2 |
# | / \ |
# | / \ |
# 3--------4
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 2, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 2, 0)))
# Add four faces
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[1])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[2])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[4])
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[3])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[4])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
self.mesh.add_face(face_vhandles)
self.mesh.request_vertex_status()
self.mesh.request_edge_status()
self.mesh.request_face_status()
# Get the halfedge
v2v1 = self.mesh.find_halfedge(self.vhandle[2], self.vhandle[1])
self.assertTrue(v2v1.is_valid())
self.assertTrue(self.mesh.is_collapse_ok(v2v1))
# Execute it as a crash test
self.mesh.collapse(v2v1)
def test_dereference(self):
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, -1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
# Add four faces
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[4])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[1])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[4])
self.mesh.add_face(face_vhandles)
# Test setup:
# 0 ==== 2
# |\ 0 /|
# | \ / |
# |2 1 3|
# | / \ |
# |/ 1 \|
# 3 ==== 4
# Starting vertex is 1->4
# output from fh_it.current_halfedge_handle()
current_halfedge_handles = [4, 0, 2, 10, 6, 8, 1, 12, 7, 14, 3, 11]
i = 0
for f in self.mesh.faces():
for he in self.mesh.fh(f):
self.assertEqual(he.idx(), current_halfedge_handles[i])
i += 1
def setUp(self):
self.mesh = openmesh.TriMesh()
# Add some vertices
self.vhandle = []
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, -1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
def setUp(self):
self.mesh = openmesh.TriMesh()
self.mesh.request_vertex_status()
self.mesh.request_edge_status()
self.mesh.request_halfedge_status()
self.mesh.request_face_status()
# Add some vertices
self.vhandle = []
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, 1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, 1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, 1, 1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, 1, 1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, -1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, -1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, 1, -1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, 1, -1)))
# Add six faces to form a cube
self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[3])
self.mesh.add_face(self.vhandle[1], self.vhandle[2], self.vhandle[3])
self.mesh.add_face(self.vhandle[7], self.vhandle[6], self.vhandle[5])
self.mesh.add_face(self.vhandle[7], self.vhandle[5], self.vhandle[4])
self.mesh.add_face(self.vhandle[1], self.vhandle[0], self.vhandle[4])
self.mesh.add_face(self.vhandle[1], self.vhandle[4], self.vhandle[5])
self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[5])
self.mesh.add_face(self.vhandle[2], self.vhandle[5], self.vhandle[6])
self.mesh.add_face(self.vhandle[3], self.vhandle[2], self.vhandle[6])
self.mesh.add_face(self.vhandle[3], self.vhandle[6], self.vhandle[7])
self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[7])
self.mesh.add_face(self.vhandle[0], self.vhandle[7], self.vhandle[4])
def test_compute_triangle_surface_with_cross_product(self):
# vec1
# y
# |
# |
# |
# x------>x vec2
vec1 = openmesh.Vec3d(0.0, 1.0, 0.0)
vec2 = openmesh.Vec3d(1.0, 0.0, 0.0)
area = 0.5 * openmesh.cross(vec1, vec2).norm()
self.assertEqual(area, 0.5)
area = 0.5 * (vec1 % vec2).norm()
self.assertEqual(area, 0.5)
def test_calc_vertex_normal_loop(self):
self.mesh.request_vertex_normals()
self.mesh.request_halfedge_normals()
self.mesh.request_face_normals()
normal = openmesh.Vec3d()
self.mesh.calc_vertex_normal_loop(self.vhandle[2], normal)
def setUp(self):
self.mesh = openmesh.TriMesh()
# Add some vertices
self.vhandle = []
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, -1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
# Add four faces
self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
self.mesh.add_face(self.vhandle[1], self.vhandle[3], self.vhandle[4])
self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[1])
self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[4])
'''
def test_face_face_iter_with_holes(self):
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(4, 1, 0)))
# Add three faces
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[3])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[4])
self.mesh.add_face(face_vhandles)
# Test setup:
#
# 0 ------ 2 ------ 4
# \ / \ /
# \ 0 / \ 2 /
# \ / 1 \ /
# 1 ------- 3
ff_it = self.mesh.ff(self.mesh.face_handle(1))
self.assertEqual(ff_it.__next__().idx(), 2)
self.assertEqual(ff_it.__next__().idx(), 0)
self.assertRaises(StopIteration, ff_it.__next__)
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 setUp(self):
self.mesh = openmesh.TriMesh()
# Add some vertices
self.vhandle = []
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, -1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
# Add four faces using Python lists
vertex_list = [self.vhandle[0], self.vhandle[1], self.vhandle[2]]
self.mesh.add_face(vertex_list)
vertex_list = [self.vhandle[1], self.vhandle[3], self.vhandle[4]]
self.mesh.add_face(vertex_list)
vertex_list = [self.vhandle[0], self.vhandle[3], self.vhandle[1]]
self.mesh.add_face(vertex_list)
vertex_list = [self.vhandle[2], self.vhandle[1], self.vhandle[4]]
self.mesh.add_face(vertex_list)
def test_face_face_iter_without_holes(self):
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
# Add two faces
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[1])
fh1 = self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[2])
fh2 = self.mesh.add_face(face_vhandles)
# Test setup:
#
# 1 -------- 2
# | f0 / |
# | / f1 |
# 0 -------- 3
# Check setup
self.assertEqual(self.mesh.n_vertices(), 4)
self.assertEqual(self.mesh.n_faces(), 2)
face_iter = self.mesh.ff(fh1)
# Get the face via the handle
faceHandle1 = face_iter.__next__()
face1 = self.mesh.face(faceHandle1)
self.assertEqual(faceHandle1.idx(), 1)
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_split_copy_polymesh(self):
self.mesh = openmesh.PolyMesh()
self.vhandle = []
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0.5, 0.5, 0)))
# Add one face
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[3])
fh = self.mesh.add_face(face_vhandles)
# Test setup:
# 1 === 2
# | |
# | |
# | |
# 0 === 3
# Set property
fprop_int = openmesh.FPropHandle()
self.mesh.add_property(fprop_int)
self.mesh.set_property(fprop_int, fh, 999)
# Split face with new vertex
self.mesh.split_copy(fh, self.vhandle[4])
# Check setup
for f in self.mesh.faces():
self.assertEqual(self.mesh.property(fprop_int, f), 999)
def setUp(self):
self.mesh = openmesh.TriMesh()
# Add some vertices
self.vhandle = []
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 1)))
# Add four faces
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[3])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[3])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[0])
self.mesh.add_face(face_vhandles)
def test_halfedge_loop_without_face(self):
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(4, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
# Add three faces
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[4])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[5])
face_vhandles.append(self.vhandle[3])
self.mesh.add_face(face_vhandles)
# Test setup:
#
# H => hole (no face)
# fx => face #x
# edge 0 => halfedge 0/1
#
# 0 --4--- 2 -10--- 4
# \ / \ /
# 0 f0 2 6 f2 8
# \ / H \ /
# 1 ---16---3
# \ /
# 12 f3 14
# \ /
# \ /
# 5
# Circle around the hole
hl_it = self.mesh.hl(self.mesh.halfedge_handle(3))
self.assertEqual(hl_it.__next__().idx(), 3)
self.assertEqual(hl_it.__next__().idx(), 17)
self.assertEqual(hl_it.__next__().idx(), 7)
self.assertRaises(StopIteration, hl_it.__next__)
def setUp(self):
self.mesh = openmesh.TriMesh()
# Add some vertices
self.vhandle = []
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,-1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2,-1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3, 0, 0)))
# Single point
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0,-2, 0)))
# Add five faces
self.fhandle = []
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
self.fhandle.append(self.mesh.add_face(face_vhandles))
face_vhandles = []
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[4])
self.fhandle.append(self.mesh.add_face(face_vhandles))
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[1])
self.fhandle.append(self.mesh.add_face(face_vhandles))
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[4])
self.fhandle.append(self.mesh.add_face(face_vhandles))
face_vhandles = []
face_vhandles.append(self.vhandle[5])
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[4])
self.fhandle.append(self.mesh.add_face(face_vhandles))
def test_is_estimated_feature_edge(self):
# Test setup:
# 1 -- 2
# | / |
# | / |
# 0 -- 3
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
# Add two faces
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[3])
self.mesh.add_face(face_vhandles)
# ===============================================
# Setup complete
# ===============================================
he = self.mesh.halfedge_handle(4)
self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 0)
self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 2)
self.assertEqual(self.mesh.edge_handle(he).idx(), 2)
eh = self.mesh.edge_handle(he)
self.assertEqual(self.mesh.calc_dihedral_angle(eh), 0.0)
# Modify point
tmp = (openmesh.Vec3d(0.0, 0.0, -1.0) +
openmesh.Vec3d(1.0, 1.0, -1.0)) * 0.5
self.mesh.set_point(self.vhandle[2], tmp)
difference = fabs(1.36944 - self.mesh.calc_dihedral_angle(eh))
self.assertTrue(difference < 0.00001)
def test_create_strange_config(self):
self.mesh = openmesh.TriMesh()
self.vhandle = []
# 2 x-----------x 1
# \ /
# \ /
# \ /
# \ /
# \ /
# 0 x ---x 6
# /|\ |
# / | \ |
# / | \ |
# / | \|
# x----x x
# 3 4 5
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 2, 2)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3, 3, 3)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(4, 4, 4)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(5, 5, 5)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(6, 6, 6)))
self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
self.mesh.add_face(self.vhandle[0], self.vhandle[3], self.vhandle[4])
self.mesh.add_face(self.vhandle[0], self.vhandle[5], self.vhandle[6])
# non-manifold!
invalid_fh = self.mesh.add_face(self.vhandle[3], self.vhandle[0],
self.vhandle[4])
# Check setup
self.assertEqual(self.mesh.n_vertices(), 7)
self.assertEqual(self.mesh.n_faces(), 3)
self.assertEqual(invalid_fh, openmesh.TriMesh.InvalidFaceHandle)
def test_vv_iter(self):
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, -1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
# Add four faces
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[4])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[1])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[4])
self.mesh.add_face(face_vhandles)
# Test setup:
# 0 ==== 2
# |\ 0 /|
# | \ / |
# |2 1 3|
# | / \ |
# |/ 1 \|
# 3 ==== 4
# Starting vertex is 1->4
# output from vv_it.current_halfedge_handle()
current_halfedge_handles = [
5, 0, 12, 11, 6, 1, 2, 15, 3, 4, 13, 7, 8, 9, 10, 14
]
eh0 = []
eh1 = []
i = 0
for v in self.mesh.vertices():
for vv in self.mesh.vv(v):
he = openmesh.HalfedgeHandle(current_halfedge_handles[i])
eh0.append(self.mesh.edge_handle(he))
i += 1
for v in self.mesh.vertices():
for he in self.mesh.voh(v):
eh1.append(self.mesh.edge_handle(he))
self.assertEqual(len(eh0), len(eh1))
for i in range(len(eh0)):
self.assertEqual(eh0[i], eh1[i])
def test_vf_iter_boundary(self):
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(3, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(4, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
# Add three faces
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[4])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[5])
face_vhandles.append(self.vhandle[3])
self.mesh.add_face(face_vhandles)
# Test setup:
#
# 0 ------ 2 ------ 4
# \ / \ /
# \ 0 / \ 1 /
# \ / \ /
# 1 ------- 3
# \ /
# \ 2 /
# \ /
# \ /
# 5
# output from fe_it.current_halfedge_handle()
current_halfedge_handles = [0, 2, 12, 4, 6, 8, 16, 10, 14]
fh0 = []
fh1 = []
i = 0
for v in self.mesh.vertices():
for f in self.mesh.vf(v):
he = openmesh.HalfedgeHandle(current_halfedge_handles[i])
fh0.append(self.mesh.face_handle(he))
i += 1
for v in self.mesh.vertices():
for f in self.mesh.vf(v):
fh1.append(f)
self.assertEqual(len(fh0), len(fh1))
for i in range(len(fh0)):
self.assertEqual(fh0[i], fh1[i])
def test_fe_iter(self):
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, -1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(2, -1, 0)))
# Add four faces
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[4])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[1])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[4])
self.mesh.add_face(face_vhandles)
# Test setup:
# 0 ==== 2
# |\ 0 /|
# | \ / |
# |2 1 3|
# | / \ |
# |/ 1 \|
# 3 ==== 4
# Starting vertex is 1->4
# output from fe_it.current_halfedge_handle()
current_halfedge_handles = [4, 0, 2, 10, 6, 8, 1, 12, 7, 14, 3, 11]
heh0 = []
heh1 = []
i = 0
for f in self.mesh.faces():
for e in self.mesh.fe(f):
heh0.append(
openmesh.HalfedgeHandle(current_halfedge_handles[i]))
i += 1
for f in self.mesh.faces():
for he in self.mesh.fh(f):
heh1.append(he)
self.assertEqual(len(heh0), len(heh1))
for i in range(len(heh0)):
self.assertEqual(heh0[i], heh1[i])
def test_vertex_property_copy_properties_int(self):
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 0, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(0, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 1, 0)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(1, 0, 0)))
# Add two faces
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[0])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[3])
self.mesh.add_face(face_vhandles)
# Test setup:
# 1 === 2
# | / |
# | / |
# | / |
# 0 === 3
# Check setup
self.assertEqual(self.mesh.n_vertices(), 4)
self.assertEqual(self.mesh.n_faces(), 2)
# Add a vertex property
intHandle = openmesh.VPropHandle()
self.assertFalse(self.mesh.get_property_handle(intHandle, "intProp"))
self.mesh.add_property(intHandle, "intProp")
self.assertTrue(self.mesh.get_property_handle(intHandle, "intProp"))
# Fill property
for vh in self.mesh.vertices():
self.mesh.set_property(intHandle, vh, vh.idx())
# Check if property it is ok
v_it = self.mesh.vertices()
self.assertEqual(self.mesh.property(intHandle, v_it.next()), 0)
self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
self.assertEqual(self.mesh.property(intHandle, v_it.next()), 2)
self.assertEqual(self.mesh.property(intHandle, v_it.next()), 3)
# Check vertex positions
v_it = self.mesh.vertices()
vh = v_it.next()
self.assertEqual(self.mesh.point(vh)[0], 0)
self.assertEqual(self.mesh.point(vh)[1], 0)
self.assertEqual(self.mesh.point(vh)[2], 0)
vh = v_it.next()
self.assertEqual(self.mesh.point(vh)[0], 0)
self.assertEqual(self.mesh.point(vh)[1], 1)
self.assertEqual(self.mesh.point(vh)[2], 0)
vh = v_it.next()
self.assertEqual(self.mesh.point(vh)[0], 1)
self.assertEqual(self.mesh.point(vh)[1], 1)
self.assertEqual(self.mesh.point(vh)[2], 0)
vh = v_it.next()
self.assertEqual(self.mesh.point(vh)[0], 1)
self.assertEqual(self.mesh.point(vh)[1], 0)
self.assertEqual(self.mesh.point(vh)[2], 0)
# Copy from vertex 1 to 0, with skipping build in properties
self.mesh.copy_all_properties(self.vhandle[1], self.vhandle[0])
v_it = self.mesh.vertices()
vh = v_it.next()
self.assertEqual(self.mesh.point(vh)[0], 0)
self.assertEqual(self.mesh.point(vh)[1], 0)
self.assertEqual(self.mesh.point(vh)[2], 0)
vh = v_it.next()
self.assertEqual(self.mesh.point(vh)[0], 0)
self.assertEqual(self.mesh.point(vh)[1], 1)
self.assertEqual(self.mesh.point(vh)[2], 0)
vh = v_it.next()
self.assertEqual(self.mesh.point(vh)[0], 1)
self.assertEqual(self.mesh.point(vh)[1], 1)
self.assertEqual(self.mesh.point(vh)[2], 0)
vh = v_it.next()
self.assertEqual(self.mesh.point(vh)[0], 1)
self.assertEqual(self.mesh.point(vh)[1], 0)
self.assertEqual(self.mesh.point(vh)[2], 0)
v_it = self.mesh.vertices()
self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
self.assertEqual(self.mesh.property(intHandle, v_it.next()), 2)
self.assertEqual(self.mesh.property(intHandle, v_it.next()), 3)
# Copy from vertex 2 to 3, including build in properties
self.mesh.copy_all_properties(self.vhandle[2], self.vhandle[3], True)
v_it = self.mesh.vertices()
vh = v_it.next()
self.assertEqual(self.mesh.point(vh)[0], 0)
self.assertEqual(self.mesh.point(vh)[1], 0)
self.assertEqual(self.mesh.point(vh)[2], 0)
vh = v_it.next()
self.assertEqual(self.mesh.point(vh)[0], 0)
self.assertEqual(self.mesh.point(vh)[1], 1)
self.assertEqual(self.mesh.point(vh)[2], 0)
vh = v_it.next()
self.assertEqual(self.mesh.point(vh)[0], 1)
self.assertEqual(self.mesh.point(vh)[1], 1)
self.assertEqual(self.mesh.point(vh)[2], 0)
vh = v_it.next()
self.assertEqual(self.mesh.point(vh)[0], 1)
self.assertEqual(self.mesh.point(vh)[1], 1)
self.assertEqual(self.mesh.point(vh)[2], 0)
v_it = self.mesh.vertices()
self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
self.assertEqual(self.mesh.property(intHandle, v_it.next()), 1)
self.assertEqual(self.mesh.property(intHandle, v_it.next()), 2)
self.assertEqual(self.mesh.property(intHandle, v_it.next()), 2)
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_delete_half_triangle_mesh_cube_no_edge_status(self):
self.mesh = openmesh.TriMesh()
self.vhandle = []
# Add some vertices
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, 1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, 1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, 1, 1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, 1, 1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, -1, -1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, -1, -1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 1, 1, -1)))
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, 1, -1)))
# Add six faces to form a cube
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[3])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[3])
self.mesh.add_face(face_vhandles)
#=======================
face_vhandles = []
face_vhandles.append(self.vhandle[7])
face_vhandles.append(self.vhandle[6])
face_vhandles.append(self.vhandle[5])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[7])
face_vhandles.append(self.vhandle[5])
face_vhandles.append(self.vhandle[4])
self.mesh.add_face(face_vhandles)
#=======================
face_vhandles = []
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[4])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[4])
face_vhandles.append(self.vhandle[5])
self.mesh.add_face(face_vhandles)
#=======================
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[1])
face_vhandles.append(self.vhandle[5])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[5])
face_vhandles.append(self.vhandle[6])
self.mesh.add_face(face_vhandles)
#=======================
face_vhandles = []
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[2])
face_vhandles.append(self.vhandle[6])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[6])
face_vhandles.append(self.vhandle[7])
self.mesh.add_face(face_vhandles)
#=======================
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[3])
face_vhandles.append(self.vhandle[7])
self.mesh.add_face(face_vhandles)
face_vhandles = []
face_vhandles.append(self.vhandle[0])
face_vhandles.append(self.vhandle[7])
face_vhandles.append(self.vhandle[4])
self.mesh.add_face(face_vhandles)
# Test setup:
#
# 3 ======== 2
# / /|
# / / | z
# 0 ======== 1 | |
# | | | | y
# | 7 | 6 | /
# | | / | /
# | |/ |/
# 4 ======== 5 -------> x
# Check setup
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_halfedges(), 36)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_faces(), 12)
# =====================================================
# Now we delete half of the mesh
# =====================================================
self.mesh.request_face_status()
self.mesh.request_vertex_status()
self.mesh.request_halfedge_status()
n_face_to_delete = self.mesh.n_faces() / 2
# Check the variable
self.assertEqual(n_face_to_delete, 6)
for i in range(int(n_face_to_delete)):
self.mesh.delete_face(self.mesh.face_handle(i))
# =====================================================
# Check config afterwards
# =====================================================
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_halfedges(), 36)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_faces(), 12)
# =====================================================
# Cleanup and recheck
# =====================================================
self.mesh.garbage_collection()
self.assertEqual(self.mesh.n_edges(), 18)
self.assertEqual(self.mesh.n_halfedges(), 36)
self.assertEqual(self.mesh.n_vertices(), 8)
self.assertEqual(self.mesh.n_faces(), 6)
