Python source
git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@1171 fdac6126-5c0c-442c-9429-916003d36597
This commit is contained in:
Jan Möbius
333
src/Python/Unittests/test_add_face.py
Normal file
333
src/Python/Unittests/test_add_face.py
Normal file
@@ -0,0 +1,333 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class AddFace(unittest.TestCase):
|
||||
|
||||
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_add_quad_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[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(), 2)
|
||||
|
||||
def test_create_triangle_mesh_cube(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)
|
||||
|
||||
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!
|
||||
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(), 4)
|
||||
|
||||
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_create_poly_mesh_cube(self):
|
||||
self.mesh = openmesh.PolyMesh()
|
||||
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[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])
|
||||
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])
|
||||
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])
|
||||
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])
|
||||
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])
|
||||
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(), 12)
|
||||
self.assertEqual(self.mesh.n_halfedges(), 24)
|
||||
self.assertEqual(self.mesh.n_vertices(), 8)
|
||||
self.assertEqual(self.mesh.n_faces(), 6)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(AddFace)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
86
src/Python/Unittests/test_boundary.py
Normal file
86
src/Python/Unittests/test_boundary.py
Normal file
@@ -0,0 +1,86 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class BoundaryTriangleMesh(unittest.TestCase):
|
||||
|
||||
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))
|
||||
|
||||
# Test setup:
|
||||
# 0 ==== 2
|
||||
# |\ 0 /|\
|
||||
# | \ / | \
|
||||
# |2 1 3|4 5
|
||||
# | / \ | /
|
||||
# |/ 1 \|/
|
||||
# 3 ==== 4
|
||||
#
|
||||
# Vertex 6 single
|
||||
|
||||
def test_boundary_vertex(self):
|
||||
self.assertTrue (self.mesh.is_boundary(self.vhandle[0]))
|
||||
self.assertFalse(self.mesh.is_boundary(self.vhandle[1]))
|
||||
self.assertTrue (self.mesh.is_boundary(self.vhandle[2]))
|
||||
self.assertTrue (self.mesh.is_boundary(self.vhandle[3]))
|
||||
self.assertTrue (self.mesh.is_boundary(self.vhandle[4]))
|
||||
self.assertTrue (self.mesh.is_boundary(self.vhandle[5]))
|
||||
|
||||
self.assertTrue (self.mesh.is_boundary(self.vhandle[6]))
|
||||
|
||||
def test_boundary_face(self):
|
||||
self.assertTrue (self.mesh.is_boundary(self.fhandle[0]))
|
||||
self.assertTrue (self.mesh.is_boundary(self.fhandle[1]))
|
||||
self.assertTrue (self.mesh.is_boundary(self.fhandle[2]))
|
||||
self.assertFalse(self.mesh.is_boundary(self.fhandle[3]))
|
||||
self.assertTrue (self.mesh.is_boundary(self.fhandle[4]))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(BoundaryTriangleMesh)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
530
src/Python/Unittests/test_delete_face.py
Normal file
530
src/Python/Unittests/test_delete_face.py
Normal file
@@ -0,0 +1,530 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class DeleteFaceTriangleMesh(unittest.TestCase):
|
||||
|
||||
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)
|
||||
|
||||
def test_delete_half_triangle_mesh_cube_with_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_edge_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(), 13)
|
||||
self.assertEqual(self.mesh.n_vertices(), 8)
|
||||
self.assertEqual(self.mesh.n_faces(), 6)
|
||||
|
||||
def test_deletete_half_poly_mesh_cube_without_edge_status(self):
|
||||
self.mesh = openmesh.PolyMesh()
|
||||
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[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])
|
||||
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])
|
||||
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])
|
||||
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])
|
||||
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])
|
||||
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(), 12)
|
||||
self.assertEqual(self.mesh.n_halfedges(), 24)
|
||||
self.assertEqual(self.mesh.n_vertices(), 8)
|
||||
self.assertEqual(self.mesh.n_faces(), 6)
|
||||
|
||||
# =====================================================
|
||||
# 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, 3)
|
||||
|
||||
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(), 12)
|
||||
self.assertEqual(self.mesh.n_halfedges(), 24)
|
||||
self.assertEqual(self.mesh.n_vertices(), 8)
|
||||
self.assertEqual(self.mesh.n_faces(), 6)
|
||||
|
||||
# =====================================================
|
||||
# Cleanup and recheck
|
||||
# =====================================================
|
||||
|
||||
self.mesh.garbage_collection()
|
||||
|
||||
self.assertEqual(self.mesh.n_edges(), 12)
|
||||
self.assertEqual(self.mesh.n_halfedges(), 24)
|
||||
self.assertEqual(self.mesh.n_vertices(), 8)
|
||||
self.assertEqual(self.mesh.n_faces(), 3)
|
||||
|
||||
def test_deletete_half_poly_mesh_cube_with_edge_status(self):
|
||||
self.mesh = openmesh.PolyMesh()
|
||||
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[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])
|
||||
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])
|
||||
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])
|
||||
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])
|
||||
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])
|
||||
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(), 12)
|
||||
self.assertEqual(self.mesh.n_halfedges(), 24)
|
||||
self.assertEqual(self.mesh.n_vertices(), 8)
|
||||
self.assertEqual(self.mesh.n_faces(), 6)
|
||||
|
||||
# =====================================================
|
||||
# Now we delete half of the mesh
|
||||
# =====================================================
|
||||
self.mesh.request_face_status()
|
||||
self.mesh.request_vertex_status()
|
||||
self.mesh.request_edge_status()
|
||||
self.mesh.request_halfedge_status()
|
||||
|
||||
n_face_to_delete = self.mesh.n_faces() / 2
|
||||
|
||||
# Check the variable
|
||||
self.assertEqual(n_face_to_delete, 3)
|
||||
|
||||
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(), 12)
|
||||
self.assertEqual(self.mesh.n_halfedges(), 24)
|
||||
self.assertEqual(self.mesh.n_vertices(), 8)
|
||||
self.assertEqual(self.mesh.n_faces(), 6)
|
||||
|
||||
# =====================================================
|
||||
# Cleanup and recheck
|
||||
# =====================================================
|
||||
|
||||
self.mesh.garbage_collection()
|
||||
|
||||
self.assertEqual(self.mesh.n_edges(), 10)
|
||||
self.assertEqual(self.mesh.n_halfedges(), 20)
|
||||
self.assertEqual(self.mesh.n_vertices(), 8)
|
||||
self.assertEqual(self.mesh.n_faces(), 3)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(DeleteFaceTriangleMesh)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
289
src/Python/Unittests/test_property.py
Executable file
289
src/Python/Unittests/test_property.py
Executable file
@@ -0,0 +1,289 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class Property(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.mesh = openmesh.TriMesh()
|
||||
self.vhandle = []
|
||||
|
||||
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_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_copy_all_properties_vertex_after_remove_of_property(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 double vertex property
|
||||
doubleHandle = openmesh.VPropHandle()
|
||||
self.assertFalse(self.mesh.get_property_handle(doubleHandle, "doubleProp"))
|
||||
self.mesh.add_property(doubleHandle, "doubleProp")
|
||||
self.assertTrue(self.mesh.get_property_handle(doubleHandle, "doubleProp"))
|
||||
|
||||
# Add a int 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"))
|
||||
|
||||
# Now remove the double property again
|
||||
self.mesh.remove_property(doubleHandle)
|
||||
|
||||
# Fill int 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)
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(Property)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
71
src/Python/Unittests/test_python.py
Normal file
71
src/Python/Unittests/test_python.py
Normal file
@@ -0,0 +1,71 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class Python(unittest.TestCase):
|
||||
|
||||
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)
|
||||
|
||||
# Test setup:
|
||||
# 0 ==== 2
|
||||
# |\ 0 /|
|
||||
# | \ / |
|
||||
# |2 1 3|
|
||||
# | / \ |
|
||||
# |/ 1 \|
|
||||
# 3 ==== 4
|
||||
|
||||
def test_python_iterator(self):
|
||||
# Iterate over all vertices
|
||||
indices = [0, 1, 2, 3, 4]
|
||||
for v, idx in zip(self.mesh.vertices(), indices):
|
||||
self.assertEqual(v.idx(), idx)
|
||||
|
||||
def test_python_circulator(self):
|
||||
# Iterate around vertex 1 at the middle
|
||||
indices = [4, 3, 0, 2]
|
||||
for v, idx in zip(self.mesh.vv(self.vhandle[1]), indices):
|
||||
self.assertEqual(v.idx(), idx)
|
||||
|
||||
def test_property_manager(self):
|
||||
# Check if vertex property exists
|
||||
self.assertFalse(openmesh.VPropertyManager.property_exists(self.mesh, "prop"))
|
||||
|
||||
# Create a new vertex property
|
||||
propman = openmesh.VPropertyManager(self.mesh, "prop")
|
||||
self.assertTrue(propman.property_exists(self.mesh, "prop"))
|
||||
|
||||
# Check initial property values
|
||||
for v in self.mesh.vertices():
|
||||
self.assertEqual(propman[v], None)
|
||||
|
||||
# Set property values
|
||||
propman.set_range(self.mesh.vertices(), 0.0)
|
||||
|
||||
# Check again
|
||||
for v in self.mesh.vertices():
|
||||
self.assertEqual(propman[v], 0.0)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(Python)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
229
src/Python/Unittests/test_read_write_obj.py
Normal file
229
src/Python/Unittests/test_read_write_obj.py
Normal file
@@ -0,0 +1,229 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class ReadWriteOBJ(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.mesh = openmesh.TriMesh()
|
||||
|
||||
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 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()
|
||||
|
||||
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_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_simple_obj_with_vertex_colors_after_vertices(self):
|
||||
self.mesh.request_vertex_colors()
|
||||
|
||||
options = openmesh.Options()
|
||||
options += openmesh.Options.VertexColor
|
||||
|
||||
file_name = "cube-minimal-vertex-colors-after-vertex-definition.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_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()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(ReadWriteOBJ)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
163
src/Python/Unittests/test_read_write_off.py
Normal file
163
src/Python/Unittests/test_read_write_off.py
Normal file
@@ -0,0 +1,163 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class ReadWriteOFF(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.mesh = openmesh.TriMesh()
|
||||
|
||||
def test_load_simple_off_file(self):
|
||||
ok = openmesh.read_mesh(self.mesh, "cube1.off")
|
||||
|
||||
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_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_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.ColorFloat
|
||||
|
||||
# Write the mesh
|
||||
ok = openmesh.write_mesh(self.mesh, "cube_floating.off", options)
|
||||
self.assertTrue(ok)
|
||||
ok = openmesh.read_mesh(self.mesh, "cube_floating.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.assertTrue(options.vertex_has_color())
|
||||
self.assertTrue(options.color_is_float())
|
||||
|
||||
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()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(ReadWriteOFF)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
201
src/Python/Unittests/test_read_write_om.py
Normal file
201
src/Python/Unittests/test_read_write_om.py
Normal file
@@ -0,0 +1,201 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
import os
|
||||
|
||||
class ReadWriteOM(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.mesh = openmesh.TriMesh()
|
||||
|
||||
def test_load_simple_om_force_vertex_colors_although_not_available(self):
|
||||
self.mesh.request_vertex_colors()
|
||||
|
||||
file_name = "cube-minimal.om"
|
||||
|
||||
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)
|
||||
|
||||
self.assertFalse(options.vertex_has_normal())
|
||||
self.assertFalse(options.vertex_has_texcoord())
|
||||
self.assertFalse(options.vertex_has_color())
|
||||
|
||||
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_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_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_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)
|
||||
|
||||
# TODO property tests
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(ReadWriteOM)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
342
src/Python/Unittests/test_read_write_ply.py
Normal file
342
src/Python/Unittests/test_read_write_ply.py
Normal file
@@ -0,0 +1,342 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class ReadWritePLY(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.mesh = openmesh.TriMesh()
|
||||
|
||||
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_point_ply_file_with_good_encoding(self):
|
||||
ok = openmesh.read_mesh(self.mesh, "pointCloudGoodEncoding.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_ply_force_vertex_colors_although_not_available(self):
|
||||
self.mesh.request_vertex_colors()
|
||||
|
||||
file_name = "cube-minimal.ply"
|
||||
|
||||
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)
|
||||
|
||||
self.assertFalse(options.vertex_has_normal())
|
||||
self.assertFalse(options.vertex_has_texcoord())
|
||||
self.assertFalse(options.vertex_has_color())
|
||||
|
||||
def test_load_simple_ply_with_vertex_colors(self):
|
||||
self.mesh.request_vertex_colors()
|
||||
|
||||
file_name = "cube-minimal.ply"
|
||||
|
||||
options = openmesh.Options()
|
||||
options += openmesh.Options.VertexColor
|
||||
|
||||
ok = openmesh.read_mesh(self.mesh, "cube-minimal-vertexColors.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], 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_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_write_and_read_binary_ply_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)
|
||||
|
||||
options += openmesh.Options.Binary
|
||||
|
||||
ok = openmesh.write_mesh(self.mesh, "meshlab_binary.ply", options)
|
||||
self.assertTrue(ok)
|
||||
|
||||
self.mesh.clear
|
||||
|
||||
ok = openmesh.read_mesh(self.mesh, "meshlab_binary.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_write_and_read_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
|
||||
|
||||
ok = openmesh.write_mesh(self.mesh, "meshlab_float.ply", options)
|
||||
self.assertTrue(ok)
|
||||
|
||||
self.mesh.clear
|
||||
ok = openmesh.read_mesh(self.mesh, "meshlab_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.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_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()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(ReadWritePLY)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
75
src/Python/Unittests/test_read_write_stl.py
Normal file
75
src/Python/Unittests/test_read_write_stl.py
Normal file
@@ -0,0 +1,75 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class ReadWriteSTL(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.mesh = openmesh.TriMesh()
|
||||
|
||||
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_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_stl_binary_file(self):
|
||||
ok = openmesh.read_mesh(self.mesh, "cube1Binary.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_stl_binary_file_with_normals(self):
|
||||
self.mesh.request_face_normals()
|
||||
|
||||
options = openmesh.Options()
|
||||
options += openmesh.Options.FaceNormal
|
||||
options += openmesh.Options.Binary
|
||||
|
||||
ok = openmesh.read_mesh(self.mesh, "cube1Binary.stl", options)
|
||||
|
||||
self.assertTrue(ok)
|
||||
|
||||
self.assertTrue(options.is_binary())
|
||||
self.assertTrue(options.face_has_normal())
|
||||
self.assertFalse(options.vertex_has_normal())
|
||||
|
||||
self.assertAlmostEqual(self.mesh.normal(self.mesh.face_handle(0))[0], -0.038545, 5)
|
||||
self.assertAlmostEqual(self.mesh.normal(self.mesh.face_handle(0))[1], -0.004330, 5)
|
||||
self.assertAlmostEqual(self.mesh.normal(self.mesh.face_handle(0))[2], 0.999247, 5)
|
||||
|
||||
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()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(ReadWriteSTL)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
87
src/Python/Unittests/test_split_copy.py
Normal file
87
src/Python/Unittests/test_split_copy.py
Normal file
@@ -0,0 +1,87 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class SplitCopy(unittest.TestCase):
|
||||
|
||||
def test_split_copy_triangle_mesh(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(0.25, 0.25, 0)))
|
||||
|
||||
# Add one face
|
||||
face_vhandles = []
|
||||
|
||||
face_vhandles.append(self.vhandle[2])
|
||||
face_vhandles.append(self.vhandle[1])
|
||||
face_vhandles.append(self.vhandle[0])
|
||||
|
||||
fh = self.mesh.add_face(face_vhandles)
|
||||
|
||||
# Test setup:
|
||||
# 1 === 2
|
||||
# | /
|
||||
# | /
|
||||
# | /
|
||||
# 0
|
||||
|
||||
# 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[3])
|
||||
|
||||
# Check setup
|
||||
for f in self.mesh.faces():
|
||||
self.assertEqual(self.mesh.property(fprop_int, f), 999)
|
||||
|
||||
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)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(SplitCopy)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
@@ -0,0 +1,269 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TrimeshCirculatorCurrentHalfedgeHandleReplacement(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.mesh = openmesh.TriMesh()
|
||||
self.vhandle = []
|
||||
|
||||
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 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_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_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])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TrimeshCirculatorCurrentHalfedgeHandleReplacement)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
50
src/Python/Unittests/test_trimesh_circulator_face_edge.py
Normal file
50
src/Python/Unittests/test_trimesh_circulator_face_edge.py
Normal file
@@ -0,0 +1,50 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TriMeshCirculatorFaceEdge(unittest.TestCase):
|
||||
|
||||
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(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 four faces
|
||||
self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
|
||||
self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[3])
|
||||
self.mesh.add_face(self.vhandle[2], self.vhandle[3], self.vhandle[4])
|
||||
self.mesh.add_face(self.vhandle[1], self.vhandle[5], self.vhandle[3])
|
||||
|
||||
'''
|
||||
Test setup:
|
||||
0 ------ 2 ------ 4
|
||||
\ / \ /
|
||||
\ 0 / \ 2 /
|
||||
\ / 1 \ /
|
||||
1 ------- 3
|
||||
\ /
|
||||
\ 3 /
|
||||
\ /
|
||||
\ /
|
||||
5
|
||||
'''
|
||||
|
||||
def test_face_edge_iter_without_holes_increment(self):
|
||||
# Iterate around face 1 at the middle
|
||||
fe_it = openmesh.FaceEdgeIter(self.mesh, self.mesh.face_handle(1))
|
||||
self.assertEqual(fe_it.__next__().idx(), 4)
|
||||
self.assertEqual(fe_it.__next__().idx(), 1)
|
||||
self.assertEqual(fe_it.__next__().idx(), 3)
|
||||
self.assertRaises(StopIteration, fe_it.__next__)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorFaceEdge)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
156
src/Python/Unittests/test_trimesh_circulator_face_face.py
Normal file
156
src/Python/Unittests/test_trimesh_circulator_face_face.py
Normal file
@@ -0,0 +1,156 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TrimeshCirculatorFaceFace(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.mesh = openmesh.TriMesh()
|
||||
self.vhandle = []
|
||||
|
||||
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_face_face_iter_without_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)))
|
||||
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[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)
|
||||
|
||||
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 / \ 2 /
|
||||
# \ / 1 \ /
|
||||
# 1 ------- 3
|
||||
# \ /
|
||||
# \ 3 /
|
||||
# \ /
|
||||
# \ /
|
||||
# 5
|
||||
|
||||
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.assertEqual(ff_it.__next__().idx(), 3)
|
||||
self.assertRaises(StopIteration, ff_it.__next__)
|
||||
|
||||
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)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TrimeshCirculatorFaceFace)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
@@ -0,0 +1,50 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TriMeshCirculatorFaceHalfEdge(unittest.TestCase):
|
||||
|
||||
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(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 four faces
|
||||
self.mesh.add_face(self.vhandle[0], self.vhandle[1], self.vhandle[2])
|
||||
self.mesh.add_face(self.vhandle[2], self.vhandle[1], self.vhandle[3])
|
||||
self.mesh.add_face(self.vhandle[2], self.vhandle[3], self.vhandle[4])
|
||||
self.mesh.add_face(self.vhandle[1], self.vhandle[5], self.vhandle[3])
|
||||
|
||||
'''
|
||||
Test setup:
|
||||
0 ------ 2 ------ 4
|
||||
\ / \ /
|
||||
\ 0 / \ 2 /
|
||||
\ / 1 \ /
|
||||
1 ------- 3
|
||||
\ /
|
||||
\ 3 /
|
||||
\ /
|
||||
\ /
|
||||
5
|
||||
'''
|
||||
|
||||
def test_face_halfedge_iter_without_holes_increment(self):
|
||||
# Iterate around face 1 at the middle
|
||||
fh_it = openmesh.FaceHalfedgeIter(self.mesh, self.mesh.face_handle(1))
|
||||
self.assertEqual(fh_it.__next__().idx(), 8)
|
||||
self.assertEqual(fh_it.__next__().idx(), 3)
|
||||
self.assertEqual(fh_it.__next__().idx(), 6)
|
||||
self.assertRaises(StopIteration, fh_it.__next__)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorFaceHalfEdge)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
48
src/Python/Unittests/test_trimesh_circulator_face_vertex.py
Normal file
48
src/Python/Unittests/test_trimesh_circulator_face_vertex.py
Normal file
@@ -0,0 +1,48 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TriMeshCirculatorFaceVertex(unittest.TestCase):
|
||||
|
||||
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.fh0 = 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])
|
||||
|
||||
'''
|
||||
Test setup:
|
||||
0 ==== 2
|
||||
|\ 0 /|
|
||||
| \ / |
|
||||
|2 1 3|
|
||||
| / \ |
|
||||
|/ 1 \|
|
||||
3 ==== 4
|
||||
'''
|
||||
|
||||
def test_face_vertex_iter_without_increment(self):
|
||||
self.assertEqual(self.fh0.idx(), 0)
|
||||
|
||||
# Iterate around face 0 at the top
|
||||
fv_it = openmesh.FaceVertexIter(self.mesh, self.fh0)
|
||||
self.assertEqual(fv_it.__next__().idx(), 0)
|
||||
self.assertEqual(fv_it.__next__().idx(), 1)
|
||||
self.assertEqual(fv_it.__next__().idx(), 2)
|
||||
self.assertRaises(StopIteration, fv_it.__next__)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorFaceVertex)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
131
src/Python/Unittests/test_trimesh_circulator_halfedge_loop.py
Normal file
131
src/Python/Unittests/test_trimesh_circulator_halfedge_loop.py
Normal file
@@ -0,0 +1,131 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TrimeshCirculatorHalfedgeLoop(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.mesh = openmesh.TriMesh()
|
||||
self.vhandle = []
|
||||
|
||||
def test_halfedge_loop_with_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 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[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)
|
||||
|
||||
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:
|
||||
#
|
||||
# edge x => halfedge x/x+1
|
||||
# i.e. edge 0 => halfedge 0/1
|
||||
#
|
||||
# 0 --4--- 2 ------ 4
|
||||
# \ / \ /
|
||||
# 0 0 2 6 2 /
|
||||
# \ / 1 \ /
|
||||
# 1 ---8--- 3
|
||||
# \ /
|
||||
# \ 3 /
|
||||
# \ /
|
||||
# \ /
|
||||
# 5
|
||||
|
||||
# Circle around face 1
|
||||
hl_it = self.mesh.hl(self.mesh.halfedge_handle(3))
|
||||
|
||||
self.assertEqual(hl_it.__next__().idx(), 3)
|
||||
self.assertEqual(hl_it.__next__().idx(), 6)
|
||||
self.assertEqual(hl_it.__next__().idx(), 8)
|
||||
self.assertRaises(StopIteration, hl_it.__next__)
|
||||
|
||||
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__)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TrimeshCirculatorHalfedgeLoop)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
55
src/Python/Unittests/test_trimesh_circulator_vertex_edge.py
Normal file
55
src/Python/Unittests/test_trimesh_circulator_vertex_edge.py
Normal file
@@ -0,0 +1,55 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TriMeshCirculatorVertexEdge(unittest.TestCase):
|
||||
|
||||
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])
|
||||
|
||||
'''
|
||||
Test setup:
|
||||
0 ==== 2
|
||||
|\ 0 /|
|
||||
| \ / |
|
||||
|2 1 3|
|
||||
| / \ |
|
||||
|/ 1 \|
|
||||
3 ==== 4
|
||||
'''
|
||||
|
||||
def test_vertex_edge_iter_without_holes_increment(self):
|
||||
# Iterate around vertex 1 at the middle
|
||||
ve_it = openmesh.VertexEdgeIter(self.mesh, self.vhandle[1])
|
||||
self.assertEqual(ve_it.__next__().idx(), 5)
|
||||
self.assertEqual(ve_it.__next__().idx(), 3)
|
||||
self.assertEqual(ve_it.__next__().idx(), 0)
|
||||
self.assertEqual(ve_it.__next__().idx(), 1)
|
||||
self.assertRaises(StopIteration, ve_it.__next__)
|
||||
|
||||
def test_vertex_edge_iter_boundary_increment(self):
|
||||
# Iterate around vertex 2 at the boundary
|
||||
ve_it = openmesh.VertexEdgeIter(self.mesh, self.vhandle[2])
|
||||
self.assertEqual(ve_it.__next__().idx(), 7)
|
||||
self.assertEqual(ve_it.__next__().idx(), 1)
|
||||
self.assertEqual(ve_it.__next__().idx(), 2)
|
||||
self.assertRaises(StopIteration, ve_it.__next__)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorVertexEdge)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
93
src/Python/Unittests/test_trimesh_circulator_vertex_face.py
Normal file
93
src/Python/Unittests/test_trimesh_circulator_vertex_face.py
Normal file
@@ -0,0 +1,93 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TriMeshCirculatorVertexFace(unittest.TestCase):
|
||||
|
||||
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 test_vertex_face_iter_with_holes_increment(self):
|
||||
# Add two 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])
|
||||
|
||||
'''
|
||||
Test setup:
|
||||
0 ==== 2
|
||||
\ /
|
||||
\ /
|
||||
1
|
||||
/ \
|
||||
/ \
|
||||
3 ==== 4
|
||||
'''
|
||||
|
||||
# Iterate around vertex 1 at the middle (with holes in between)
|
||||
vf_it = openmesh.VertexFaceIter(self.mesh, self.vhandle[1])
|
||||
self.assertEqual(vf_it.__next__().idx(), 0)
|
||||
self.assertEqual(vf_it.__next__().idx(), 1)
|
||||
self.assertRaises(StopIteration, vf_it.__next__)
|
||||
|
||||
def test_vertex_face_iter_without_holes_increment(self):
|
||||
# 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])
|
||||
|
||||
'''
|
||||
Test setup:
|
||||
0 ==== 2
|
||||
|\ 0 /|
|
||||
| \ / |
|
||||
|2 1 3|
|
||||
| / \ |
|
||||
|/ 1 \|
|
||||
3 ==== 4
|
||||
'''
|
||||
|
||||
# Iterate around vertex 1 at the middle (without holes in between)
|
||||
vf_it = openmesh.VertexFaceIter(self.mesh, self.vhandle[1])
|
||||
self.assertEqual(vf_it.__next__().idx(), 3)
|
||||
self.assertEqual(vf_it.__next__().idx(), 1)
|
||||
self.assertEqual(vf_it.__next__().idx(), 2)
|
||||
self.assertEqual(vf_it.__next__().idx(), 0)
|
||||
self.assertRaises(StopIteration, vf_it.__next__)
|
||||
|
||||
def test_vertex_face_iter_boundary_increment(self):
|
||||
# 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])
|
||||
|
||||
'''
|
||||
Test setup:
|
||||
0 ==== 2
|
||||
|\ 0 /|
|
||||
| \ / |
|
||||
|2 1 3|
|
||||
| / \ |
|
||||
|/ 1 \|
|
||||
3 ==== 4
|
||||
'''
|
||||
|
||||
# Iterate around vertex 2 at the boundary (without holes in between)
|
||||
vf_it = openmesh.VertexFaceIter(self.mesh, self.vhandle[2])
|
||||
self.assertEqual(vf_it.__next__().idx(), 3)
|
||||
self.assertEqual(vf_it.__next__().idx(), 0)
|
||||
self.assertRaises(StopIteration, vf_it.__next__)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorVertexFace)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
@@ -0,0 +1,80 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TriMeshCirculatorVertexIHalfEdge(unittest.TestCase):
|
||||
|
||||
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])
|
||||
|
||||
'''
|
||||
Test setup:
|
||||
0 ==== 2
|
||||
|\ 0 /|
|
||||
| \ / |
|
||||
|2 1 3|
|
||||
| / \ |
|
||||
|/ 1 \|
|
||||
3 ==== 4
|
||||
Starting halfedge is 1->4
|
||||
'''
|
||||
|
||||
def test_vertex_incoming_halfedge_without_holes_increment(self):
|
||||
# Iterate around vertex 1 at the middle
|
||||
vih_it = openmesh.VertexIHalfedgeIter(self.mesh, self.vhandle[1])
|
||||
heh = vih_it.__next__()
|
||||
self.assertEqual(heh.idx(), 10)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), 1)
|
||||
heh = vih_it.__next__()
|
||||
self.assertEqual(heh.idx(), 7)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), 2)
|
||||
heh = vih_it.__next__()
|
||||
self.assertEqual(heh.idx(), 0)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), 0)
|
||||
heh = vih_it.__next__()
|
||||
self.assertEqual(heh.idx(), 3)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), 3)
|
||||
self.assertRaises(StopIteration, vih_it.__next__)
|
||||
|
||||
def test_vertex_incoming_halfedge_boundary_increment(self):
|
||||
# Iterate around vertex 2 at the boundary
|
||||
vih_it = openmesh.VertexIHalfedgeIter(self.mesh, self.vhandle[2])
|
||||
heh = vih_it.__next__()
|
||||
self.assertEqual(heh.idx(), 14)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), 3)
|
||||
heh = vih_it.__next__()
|
||||
self.assertEqual(heh.idx(), 2)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), 0)
|
||||
heh = vih_it.__next__()
|
||||
self.assertEqual(heh.idx(), 5)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), -1)
|
||||
self.assertRaises(StopIteration, vih_it.__next__)
|
||||
|
||||
def test_vertex_incoming_halfedge_dereference_increment(self):
|
||||
# Iterate around vertex 1 at the middle
|
||||
vih_it = openmesh.VertexIHalfedgeIter(self.mesh, self.vhandle[1])
|
||||
heh = vih_it.__next__()
|
||||
eh = self.mesh.edge_handle(heh)
|
||||
vh = self.mesh.to_vertex_handle(heh)
|
||||
self.assertEqual(heh.idx(), 10)
|
||||
self.assertEqual(eh.idx(), 5)
|
||||
self.assertEqual(vh.idx(), 1)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorVertexIHalfEdge)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
@@ -0,0 +1,80 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TriMeshCirculatorVertexOHalfEdge(unittest.TestCase):
|
||||
|
||||
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])
|
||||
|
||||
'''
|
||||
Test setup:
|
||||
0 ==== 2
|
||||
|\ 0 /|
|
||||
| \ / |
|
||||
|2 1 3|
|
||||
| / \ |
|
||||
|/ 1 \|
|
||||
3 ==== 4
|
||||
Starting halfedge is 1->4
|
||||
'''
|
||||
|
||||
def test_vertex_outgoing_halfedge_without_holes_increment(self):
|
||||
# Iterate around vertex 1 at the middle
|
||||
voh_it = openmesh.VertexOHalfedgeIter(self.mesh, self.vhandle[1])
|
||||
heh = voh_it.__next__()
|
||||
self.assertEqual(heh.idx(), 11)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), 3)
|
||||
heh = voh_it.__next__()
|
||||
self.assertEqual(heh.idx(), 6)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), 1)
|
||||
heh = voh_it.__next__()
|
||||
self.assertEqual(heh.idx(), 1)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), 2)
|
||||
heh = voh_it.__next__()
|
||||
self.assertEqual(heh.idx(), 2)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), 0)
|
||||
self.assertRaises(StopIteration, voh_it.__next__)
|
||||
|
||||
def test_vertex_outgoing_halfedge_boundary_increment(self):
|
||||
# Iterate around vertex 2 at the boundary
|
||||
voh_it = openmesh.VertexOHalfedgeIter(self.mesh, self.vhandle[2])
|
||||
heh = voh_it.__next__()
|
||||
self.assertEqual(heh.idx(), 15)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), -1)
|
||||
heh = voh_it.__next__()
|
||||
self.assertEqual(heh.idx(), 3)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), 3)
|
||||
heh = voh_it.__next__()
|
||||
self.assertEqual(heh.idx(), 4)
|
||||
self.assertEqual(self.mesh.face_handle(heh).idx(), 0)
|
||||
self.assertRaises(StopIteration, voh_it.__next__)
|
||||
|
||||
def test_vertex_outgoing_halfedge_dereference_increment(self):
|
||||
# Iterate around vertex 1 at the middle
|
||||
voh_it = openmesh.VertexOHalfedgeIter(self.mesh, self.vhandle[1])
|
||||
heh = voh_it.__next__()
|
||||
eh = self.mesh.edge_handle(heh)
|
||||
vh = self.mesh.to_vertex_handle(heh)
|
||||
self.assertEqual(heh.idx(), 11)
|
||||
self.assertEqual(eh.idx(), 5)
|
||||
self.assertEqual(vh.idx(), 4)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorVertexOHalfEdge)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
@@ -0,0 +1,56 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TriMeshCirculatorVertexVertex(unittest.TestCase):
|
||||
|
||||
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])
|
||||
|
||||
'''
|
||||
Test setup:
|
||||
0 ==== 2
|
||||
|\ 0 /|
|
||||
| \ / |
|
||||
|2 1 3|
|
||||
| / \ |
|
||||
|/ 1 \|
|
||||
3 ==== 4
|
||||
Starting vertex is 1->4
|
||||
'''
|
||||
|
||||
def test_vertex_vertex_increment(self):
|
||||
# Iterate around vertex 1 at the middle
|
||||
vv_it = openmesh.VertexVertexIter(self.mesh, self.vhandle[1])
|
||||
self.assertEqual(vv_it.__next__().idx(), 4)
|
||||
self.assertEqual(vv_it.__next__().idx(), 3)
|
||||
self.assertEqual(vv_it.__next__().idx(), 0)
|
||||
self.assertEqual(vv_it.__next__().idx(), 2)
|
||||
self.assertRaises(StopIteration, vv_it.__next__)
|
||||
|
||||
def test_vertex_vertex_boundary_increment(self):
|
||||
# Iterate around vertex 2 at the boundary
|
||||
vv_it = openmesh.VertexVertexIter(self.mesh, self.vhandle[2])
|
||||
self.assertEqual(vv_it.__next__().idx(), 4)
|
||||
self.assertEqual(vv_it.__next__().idx(), 1)
|
||||
self.assertEqual(vv_it.__next__().idx(), 0)
|
||||
self.assertRaises(StopIteration, vv_it.__next__)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshCirculatorVertexVertex)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
516
src/Python/Unittests/test_trimesh_collapse.py
Normal file
516
src/Python/Unittests/test_trimesh_collapse.py
Normal file
@@ -0,0 +1,516 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class Collapse(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.mesh = openmesh.TriMesh()
|
||||
self.vhandle = []
|
||||
|
||||
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_collapse_tetrahedron_complex(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 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)
|
||||
|
||||
self.mesh.request_vertex_status()
|
||||
self.mesh.request_edge_status()
|
||||
self.mesh.request_face_status()
|
||||
|
||||
v0v1 = self.mesh.halfedge_handle(0)
|
||||
v1v0 = self.mesh.opposite_halfedge_handle(v0v1)
|
||||
|
||||
v1vL = self.mesh.next_halfedge_handle(v0v1)
|
||||
vLv1 = self.mesh.opposite_halfedge_handle(v1vL)
|
||||
vLv0 = self.mesh.next_halfedge_handle(v1vL)
|
||||
v0vL = self.mesh.opposite_halfedge_handle(vLv0)
|
||||
|
||||
vLvR = self.mesh.next_halfedge_handle(v0vL)
|
||||
vRvL = self.mesh.opposite_halfedge_handle(vLvR)
|
||||
|
||||
v0vR = self.mesh.next_halfedge_handle(v1v0)
|
||||
vRv0 = self.mesh.opposite_halfedge_handle(v0vR)
|
||||
vRv1 = self.mesh.next_halfedge_handle(v0vR)
|
||||
v1vR = self.mesh.opposite_halfedge_handle(vRv1)
|
||||
|
||||
v0 = self.mesh.from_vertex_handle(v0v1)
|
||||
v1 = self.mesh.to_vertex_handle(v0v1)
|
||||
vL = self.mesh.to_vertex_handle(self.mesh.next_halfedge_handle(v0v1))
|
||||
vR = self.mesh.to_vertex_handle(self.mesh.next_halfedge_handle(v1v0))
|
||||
|
||||
# ===================================================================
|
||||
# Check preconditions
|
||||
# ===================================================================
|
||||
|
||||
self.assertTrue(self.mesh.is_collapse_ok(v0v1))
|
||||
self.assertTrue(self.mesh.is_collapse_ok(v1v0))
|
||||
|
||||
# Test the Vertex indices
|
||||
self.assertEqual(v0.idx(), 0)
|
||||
self.assertEqual(v1.idx(), 1)
|
||||
self.assertEqual(vL.idx(), 2)
|
||||
self.assertEqual(vR.idx(), 3)
|
||||
|
||||
# Check the halfedges
|
||||
self.assertEqual(v0v1.idx(), 0)
|
||||
self.assertEqual(v1v0.idx(), 1)
|
||||
|
||||
self.assertEqual(v1vL.idx(), 2)
|
||||
self.assertEqual(vLv1.idx(), 3)
|
||||
self.assertEqual(vLv0.idx(), 4)
|
||||
self.assertEqual(v0vL.idx(), 5)
|
||||
|
||||
self.assertEqual(vLvR.idx(), 6)
|
||||
self.assertEqual(vRvL.idx(), 7)
|
||||
|
||||
self.assertEqual(vRv0.idx(), 8)
|
||||
self.assertEqual(v0vR.idx(), 9)
|
||||
|
||||
self.assertEqual(v1vR.idx(), 10)
|
||||
self.assertEqual(vRv1.idx(), 11)
|
||||
|
||||
# ===================================================================
|
||||
# Execute collapse
|
||||
# ===================================================================
|
||||
|
||||
self.mesh.collapse(v0v1)
|
||||
|
||||
# ===================================================================
|
||||
# Check configuration afterwards
|
||||
# ===================================================================
|
||||
|
||||
# Now the configuration should look like this:
|
||||
# The numbers at the side denote the halfedges
|
||||
# 1
|
||||
# / \
|
||||
# / \
|
||||
# // \\
|
||||
# 3/2 11\10
|
||||
# // \\
|
||||
# / 6--> \
|
||||
# 2 ----------- 3
|
||||
# <--7
|
||||
|
||||
self.assertEqual(self.mesh.n_faces(), 4)
|
||||
|
||||
# Check if the right vertices got deleted
|
||||
self.assertTrue(self.mesh.status(self.mesh.face_handle(0)).deleted())
|
||||
self.assertFalse(self.mesh.status(self.mesh.face_handle(1)).deleted())
|
||||
self.assertFalse(self.mesh.status(self.mesh.face_handle(2)).deleted())
|
||||
self.assertTrue(self.mesh.status(self.mesh.face_handle(3)).deleted())
|
||||
|
||||
# Check the vertices of the two remaining faces
|
||||
fh_1 = self.mesh.face_handle(1)
|
||||
fh_2 = self.mesh.face_handle(2)
|
||||
|
||||
fv_it = self.mesh.fv(fh_1)
|
||||
|
||||
self.assertTrue(fv_it.__next__().idx(), 1)
|
||||
self.assertTrue(fv_it.__next__().idx(), 2)
|
||||
self.assertTrue(fv_it.__next__().idx(), 3)
|
||||
|
||||
fv_it = self.mesh.fv(fh_2)
|
||||
|
||||
self.assertTrue(fv_it.__next__().idx(), 2)
|
||||
self.assertTrue(fv_it.__next__().idx(), 1)
|
||||
self.assertTrue(fv_it.__next__().idx(), 3)
|
||||
|
||||
# Get the first halfedge of face 1
|
||||
fh_1_he = self.mesh.halfedge_handle(fh_1)
|
||||
|
||||
self.assertEqual(fh_1_he.idx(), 11)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(fh_1_he).idx(), 1)
|
||||
|
||||
next = self.mesh.next_halfedge_handle(fh_1_he)
|
||||
self.assertEqual(next.idx(), 2)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 2)
|
||||
|
||||
next = self.mesh.next_halfedge_handle(next)
|
||||
self.assertEqual(next.idx(), 6)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 3)
|
||||
|
||||
# Get the first halfedge of face 2
|
||||
fh_2_he = self.mesh.halfedge_handle(fh_2)
|
||||
|
||||
self.assertEqual(fh_2_he.idx(), 7)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(fh_2_he).idx(), 2)
|
||||
|
||||
next = self.mesh.next_halfedge_handle(fh_2_he)
|
||||
self.assertEqual(next.idx(), 3)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 1)
|
||||
|
||||
next = self.mesh.next_halfedge_handle(next)
|
||||
self.assertEqual(next.idx(), 10)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 3)
|
||||
|
||||
# Vertex 1 outgoing
|
||||
voh_it = self.mesh.voh(self.mesh.vertex_handle(1))
|
||||
self.assertEqual(voh_it.__next__().idx(), 10)
|
||||
self.assertEqual(voh_it.__next__().idx(), 2)
|
||||
self.assertRaises(StopIteration, voh_it.__next__)
|
||||
|
||||
# Vertex 2 outgoing
|
||||
voh_it = self.mesh.voh(self.mesh.vertex_handle(2))
|
||||
self.assertEqual(voh_it.__next__().idx(), 3)
|
||||
self.assertEqual(voh_it.__next__().idx(), 6)
|
||||
self.assertRaises(StopIteration, voh_it.__next__)
|
||||
|
||||
# Vertex 2 outgoing
|
||||
voh_it = self.mesh.voh(self.mesh.vertex_handle(3))
|
||||
self.assertEqual(voh_it.__next__().idx(), 11)
|
||||
self.assertEqual(voh_it.__next__().idx(), 7)
|
||||
self.assertRaises(StopIteration, voh_it.__next__)
|
||||
|
||||
# ===================================================================
|
||||
# Cleanup
|
||||
# ===================================================================
|
||||
self.mesh.garbage_collection()
|
||||
|
||||
# ===================================================================
|
||||
# Check configuration afterwards
|
||||
# ===================================================================
|
||||
|
||||
# Now the configuration should look like this:
|
||||
# The numbers at the side denote the halfedges
|
||||
# 0
|
||||
# / \
|
||||
# / \
|
||||
# // \\
|
||||
# 4/5 0\1
|
||||
# // \\
|
||||
# / 3--> \
|
||||
# 2 ----------- 1
|
||||
# <--2
|
||||
|
||||
self.assertEqual(self.mesh.n_faces(), 2)
|
||||
|
||||
# Check the vertices of the two remaining faces
|
||||
fh_0 = self.mesh.face_handle(0)
|
||||
fh_1 = self.mesh.face_handle(1)
|
||||
|
||||
fv_it = self.mesh.fv(fh_0)
|
||||
|
||||
self.assertEqual(fv_it.__next__().idx(), 2)
|
||||
self.assertEqual(fv_it.__next__().idx(), 1)
|
||||
self.assertEqual(fv_it.__next__().idx(), 0)
|
||||
|
||||
fv_it = self.mesh.fv(fh_1)
|
||||
|
||||
self.assertEqual(fv_it.__next__().idx(), 1)
|
||||
self.assertEqual(fv_it.__next__().idx(), 2)
|
||||
self.assertEqual(fv_it.__next__().idx(), 0)
|
||||
|
||||
# Get the first halfedge of face 1
|
||||
fh_0_he = self.mesh.halfedge_handle(fh_0)
|
||||
|
||||
self.assertEqual(fh_0_he.idx(), 5)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(fh_0_he).idx(), 2)
|
||||
|
||||
next = self.mesh.next_halfedge_handle(fh_0_he)
|
||||
self.assertEqual(next.idx(), 3)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 1)
|
||||
|
||||
next = self.mesh.next_halfedge_handle(next)
|
||||
self.assertEqual(next.idx(), 0)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 0)
|
||||
|
||||
# Get the first halfedge of face 1
|
||||
fh_1_he = self.mesh.halfedge_handle(fh_1)
|
||||
|
||||
self.assertEqual(fh_1_he.idx(), 1)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(fh_1_he).idx(), 1)
|
||||
|
||||
next = self.mesh.next_halfedge_handle(fh_1_he)
|
||||
self.assertEqual(next.idx(), 2)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 2)
|
||||
|
||||
next = self.mesh.next_halfedge_handle(next)
|
||||
self.assertEqual(next.idx(), 4)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(next).idx(), 0)
|
||||
|
||||
# Vertex 0 outgoing
|
||||
voh_it = self.mesh.voh(self.mesh.vertex_handle(0))
|
||||
self.assertEqual(voh_it.__next__().idx(), 1)
|
||||
self.assertEqual(voh_it.__next__().idx(), 5)
|
||||
self.assertRaises(StopIteration, voh_it.__next__)
|
||||
|
||||
# Vertex 1 outgoing
|
||||
voh_it = self.mesh.voh(self.mesh.vertex_handle(1))
|
||||
self.assertEqual(voh_it.__next__().idx(), 0)
|
||||
self.assertEqual(voh_it.__next__().idx(), 2)
|
||||
self.assertRaises(StopIteration, voh_it.__next__)
|
||||
|
||||
# Vertex 2 outgoing
|
||||
voh_it = self.mesh.voh(self.mesh.vertex_handle(2))
|
||||
self.assertEqual(voh_it.__next__().idx(), 3)
|
||||
self.assertEqual(voh_it.__next__().idx(), 4)
|
||||
self.assertRaises(StopIteration, voh_it.__next__)
|
||||
|
||||
self.assertFalse(self.mesh.is_collapse_ok(self.mesh.halfedge_handle(0)))
|
||||
self.assertFalse(self.mesh.is_collapse_ok(self.mesh.halfedge_handle(1)))
|
||||
self.assertFalse(self.mesh.is_collapse_ok(self.mesh.halfedge_handle(2)))
|
||||
self.assertFalse(self.mesh.is_collapse_ok(self.mesh.halfedge_handle(3)))
|
||||
self.assertFalse(self.mesh.is_collapse_ok(self.mesh.halfedge_handle(4)))
|
||||
self.assertFalse(self.mesh.is_collapse_ok(self.mesh.halfedge_handle(5)))
|
||||
|
||||
def test_collapse_tetrahedron(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, 0, 0)))
|
||||
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 0, -1, 0)))
|
||||
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 0, 1, 0)))
|
||||
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, 0, 0)))
|
||||
|
||||
# Add six faces
|
||||
face_vhandles = []
|
||||
|
||||
face_vhandles.append(self.vhandle[0])
|
||||
face_vhandles.append(self.vhandle[4])
|
||||
face_vhandles.append(self.vhandle[2])
|
||||
self.mesh.add_face(face_vhandles)
|
||||
|
||||
face_vhandles = []
|
||||
|
||||
face_vhandles.append(self.vhandle[3])
|
||||
face_vhandles.append(self.vhandle[4])
|
||||
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[4])
|
||||
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[0])
|
||||
self.mesh.add_face(face_vhandles)
|
||||
|
||||
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)
|
||||
|
||||
self.mesh.request_vertex_status()
|
||||
self.mesh.request_edge_status()
|
||||
self.mesh.request_face_status()
|
||||
|
||||
# =============================================
|
||||
# Collapse halfedge from 0 to 4
|
||||
# =============================================
|
||||
|
||||
heh_collapse1 = self.mesh.halfedge_handle(0)
|
||||
|
||||
self.assertEqual(self.mesh.to_vertex_handle(heh_collapse1).idx(), 4)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(heh_collapse1).idx(), 0)
|
||||
|
||||
self.assertTrue(self.mesh.is_collapse_ok(heh_collapse1))
|
||||
self.mesh.collapse(heh_collapse1)
|
||||
|
||||
heh_collapse2 = self.mesh.halfedge_handle(2)
|
||||
|
||||
self.assertEqual(self.mesh.to_vertex_handle(heh_collapse2).idx(), 2)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(heh_collapse2).idx(), 4)
|
||||
|
||||
self.assertTrue(self.mesh.is_collapse_ok(heh_collapse2))
|
||||
self.mesh.collapse(heh_collapse2)
|
||||
|
||||
heh_collapse3 = self.mesh.halfedge_handle(6)
|
||||
|
||||
self.assertEqual(self.mesh.to_vertex_handle(heh_collapse3).idx(), 2)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(heh_collapse3).idx(), 3)
|
||||
|
||||
self.assertFalse(self.mesh.is_collapse_ok(heh_collapse3))
|
||||
|
||||
def test_large_collapse_halfedge(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)))
|
||||
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d(-1, 0, 0)))
|
||||
self.vhandle.append(self.mesh.add_vertex(openmesh.Vec3d( 3, 0, 0)))
|
||||
|
||||
# Add six faces
|
||||
face_vhandles = []
|
||||
|
||||
face_vhandles.append(self.vhandle[0])
|
||||
face_vhandles.append(self.vhandle[5])
|
||||
face_vhandles.append(self.vhandle[1])
|
||||
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)
|
||||
|
||||
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[2])
|
||||
face_vhandles.append(self.vhandle[1])
|
||||
face_vhandles.append(self.vhandle[4])
|
||||
self.mesh.add_face(face_vhandles)
|
||||
|
||||
face_vhandles = []
|
||||
|
||||
face_vhandles.append(self.vhandle[2])
|
||||
face_vhandles.append(self.vhandle[4])
|
||||
face_vhandles.append(self.vhandle[6])
|
||||
self.mesh.add_face(face_vhandles)
|
||||
|
||||
# Test setup:
|
||||
# 0 ==== 2
|
||||
# / \ /|\
|
||||
# / \ / | \
|
||||
# 5 --- 1 | 6
|
||||
# \ / \ | /
|
||||
# \ / \|/
|
||||
# 3 ==== 4
|
||||
|
||||
# Request the status bits
|
||||
self.mesh.request_vertex_status()
|
||||
self.mesh.request_edge_status()
|
||||
self.mesh.request_face_status()
|
||||
|
||||
# =============================================
|
||||
# Collapse halfedge from 1 to 4
|
||||
# =============================================
|
||||
|
||||
heh_collapse = openmesh.HalfedgeHandle()
|
||||
|
||||
for he in self.mesh.halfedges():
|
||||
if self.mesh.from_vertex_handle(he).idx() == 1 and self.mesh.to_vertex_handle(he).idx() == 4:
|
||||
heh_collapse = he
|
||||
|
||||
# Check our halfedge
|
||||
self.assertEqual(self.mesh.to_vertex_handle(heh_collapse).idx(), 4)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(heh_collapse).idx(), 1)
|
||||
self.assertTrue(self.mesh.is_collapse_ok(heh_collapse))
|
||||
|
||||
# Remember the end vertices
|
||||
vh_from = self.mesh.from_vertex_handle(heh_collapse)
|
||||
vh_to = self.mesh.to_vertex_handle(heh_collapse)
|
||||
|
||||
# Collapse it
|
||||
self.mesh.collapse(heh_collapse)
|
||||
|
||||
self.assertTrue(self.mesh.status(vh_from).deleted())
|
||||
self.assertFalse(self.mesh.status(vh_to).deleted())
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(Collapse)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
168
src/Python/Unittests/test_trimesh_garbage_collection.py
Normal file
168
src/Python/Unittests/test_trimesh_garbage_collection.py
Normal file
@@ -0,0 +1,168 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TriMeshGarbageCollection(unittest.TestCase):
|
||||
|
||||
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])
|
||||
|
||||
# Test setup:
|
||||
#
|
||||
# 3 ======== 2
|
||||
# / /|
|
||||
# / / | z
|
||||
# 0 ======== 1 | |
|
||||
# | | | | y
|
||||
# | 7 | 6 | /
|
||||
# | | / | /
|
||||
# | |/ |/
|
||||
# 4 ======== 5 -------> x
|
||||
|
||||
def test_standard_garbage_collection(self):
|
||||
# Check setup
|
||||
self.assertEqual(self.mesh.n_vertices(), 8)
|
||||
self.assertEqual(self.mesh.n_faces(), 12)
|
||||
|
||||
self.mesh.delete_vertex(self.vhandle[0])
|
||||
|
||||
# Check setup
|
||||
self.assertEqual(self.mesh.n_vertices(), 8)
|
||||
self.assertEqual(self.mesh.n_faces(), 12)
|
||||
|
||||
self.mesh.garbage_collection()
|
||||
|
||||
# Check setup
|
||||
self.assertEqual(self.mesh.n_vertices(), 7)
|
||||
self.assertEqual(self.mesh.n_faces(), 8)
|
||||
|
||||
def test_tracked_garbage_collection(self):
|
||||
# Check setup
|
||||
self.assertEqual(self.mesh.n_vertices(), 8)
|
||||
self.assertEqual(self.mesh.n_faces(), 12)
|
||||
|
||||
#==================================================
|
||||
# Create lists containing the current handles
|
||||
#==================================================
|
||||
|
||||
vertexHandles = []
|
||||
for v in self.mesh.vertices():
|
||||
vertexHandles.append(v)
|
||||
|
||||
halfedgeHandles = []
|
||||
for he in self.mesh.halfedges():
|
||||
halfedgeHandles.append(he)
|
||||
|
||||
faceHandles = []
|
||||
for f in self.mesh.faces():
|
||||
faceHandles.append(f)
|
||||
|
||||
# Deleting vertex 0
|
||||
self.mesh.delete_vertex(self.vhandle[0])
|
||||
|
||||
# Check setup
|
||||
self.assertEqual(self.mesh.n_vertices(), 8)
|
||||
self.assertEqual(self.mesh.n_faces(), 12)
|
||||
|
||||
self.mesh.garbage_collection(vertexHandles, halfedgeHandles, faceHandles, True, True, True)
|
||||
|
||||
# Check setup
|
||||
self.assertEqual(self.mesh.n_vertices(), 7)
|
||||
self.assertEqual(self.mesh.n_faces(), 8)
|
||||
|
||||
# Check setup of vertices
|
||||
self.assertEqual(vertexHandles[0].idx(), -1)
|
||||
self.assertEqual(vertexHandles[1].idx(), 1)
|
||||
self.assertEqual(vertexHandles[2].idx(), 2)
|
||||
self.assertEqual(vertexHandles[3].idx(), 3)
|
||||
self.assertEqual(vertexHandles[4].idx(), 4)
|
||||
self.assertEqual(vertexHandles[5].idx(), 5)
|
||||
self.assertEqual(vertexHandles[6].idx(), 6)
|
||||
self.assertEqual(vertexHandles[7].idx(), 0)
|
||||
|
||||
# Check setup of halfedge handles
|
||||
self.assertEqual(halfedgeHandles[0 ].idx(), -1)
|
||||
self.assertEqual(halfedgeHandles[1 ].idx(), -1)
|
||||
self.assertEqual(halfedgeHandles[2 ].idx(), 2)
|
||||
self.assertEqual(halfedgeHandles[3 ].idx(), 3)
|
||||
self.assertEqual(halfedgeHandles[4 ].idx(), -1)
|
||||
self.assertEqual(halfedgeHandles[5 ].idx(), -1)
|
||||
self.assertEqual(halfedgeHandles[6 ].idx(), 6)
|
||||
self.assertEqual(halfedgeHandles[7 ].idx(), 7)
|
||||
self.assertEqual(halfedgeHandles[8 ].idx(), 8)
|
||||
self.assertEqual(halfedgeHandles[9 ].idx(), 9)
|
||||
self.assertEqual(halfedgeHandles[10].idx(), 10)
|
||||
self.assertEqual(halfedgeHandles[11].idx(), 11)
|
||||
self.assertEqual(halfedgeHandles[12].idx(), 12)
|
||||
self.assertEqual(halfedgeHandles[13].idx(), 13)
|
||||
self.assertEqual(halfedgeHandles[14].idx(), 14)
|
||||
self.assertEqual(halfedgeHandles[15].idx(), 15)
|
||||
self.assertEqual(halfedgeHandles[16].idx(), 16)
|
||||
self.assertEqual(halfedgeHandles[17].idx(), 17)
|
||||
self.assertEqual(halfedgeHandles[18].idx(), 18)
|
||||
self.assertEqual(halfedgeHandles[19].idx(), 19)
|
||||
self.assertEqual(halfedgeHandles[20].idx(), -1)
|
||||
self.assertEqual(halfedgeHandles[21].idx(), -1)
|
||||
self.assertEqual(halfedgeHandles[22].idx(), 22)
|
||||
self.assertEqual(halfedgeHandles[23].idx(), 23)
|
||||
self.assertEqual(halfedgeHandles[24].idx(), 24)
|
||||
self.assertEqual(halfedgeHandles[25].idx(), 25)
|
||||
self.assertEqual(halfedgeHandles[26].idx(), 26)
|
||||
self.assertEqual(halfedgeHandles[27].idx(), 27)
|
||||
self.assertEqual(halfedgeHandles[28].idx(), 20)
|
||||
self.assertEqual(halfedgeHandles[29].idx(), 21)
|
||||
self.assertEqual(halfedgeHandles[30].idx(), 4)
|
||||
self.assertEqual(halfedgeHandles[31].idx(), 5)
|
||||
self.assertEqual(halfedgeHandles[32].idx(), 0)
|
||||
self.assertEqual(halfedgeHandles[33].idx(), 1)
|
||||
self.assertEqual(halfedgeHandles[34].idx(), -1)
|
||||
self.assertEqual(halfedgeHandles[35].idx(), -1)
|
||||
|
||||
# Check setup of faces
|
||||
self.assertEqual(faceHandles[0 ].idx(), -1)
|
||||
self.assertEqual(faceHandles[1 ].idx(), 1)
|
||||
self.assertEqual(faceHandles[2 ].idx(), 2)
|
||||
self.assertEqual(faceHandles[3 ].idx(), 3)
|
||||
self.assertEqual(faceHandles[4 ].idx(), -1)
|
||||
self.assertEqual(faceHandles[5 ].idx(), 5)
|
||||
self.assertEqual(faceHandles[6 ].idx(), 6)
|
||||
self.assertEqual(faceHandles[7 ].idx(), 7)
|
||||
self.assertEqual(faceHandles[8 ].idx(), 4)
|
||||
self.assertEqual(faceHandles[9 ].idx(), 0)
|
||||
self.assertEqual(faceHandles[10].idx(), -1)
|
||||
self.assertEqual(faceHandles[11].idx(), -1)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshGarbageCollection)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
396
src/Python/Unittests/test_trimesh_iterators.py
Executable file
396
src/Python/Unittests/test_trimesh_iterators.py
Executable file
@@ -0,0 +1,396 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class TriMeshIterators(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.mesh = openmesh.TriMesh()
|
||||
self.vhandle = []
|
||||
|
||||
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_vertex_iter_start_position(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 = openmesh.VertexIter(self.mesh, self.mesh.vertex_handle(2))
|
||||
|
||||
self.assertEqual(v_it.__next__().idx(), 2)
|
||||
self.assertEqual(v_it.__next__().idx(), 3)
|
||||
|
||||
self.assertRaises(StopIteration, v_it.__next__)
|
||||
|
||||
def test_edge_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
|
||||
|
||||
e_it = self.mesh.edges()
|
||||
|
||||
e = e_it.__next__()
|
||||
self.assertEqual(e.idx(), 0)
|
||||
|
||||
he = self.mesh.halfedge_handle(e, 0)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 1)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 2)
|
||||
he = self.mesh.halfedge_handle(e, 1)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 2)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 1)
|
||||
|
||||
e = e_it.__next__()
|
||||
self.assertEqual(e.idx(), 1)
|
||||
|
||||
he = self.mesh.halfedge_handle(e, 0)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 0)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 1)
|
||||
he = self.mesh.halfedge_handle(e, 1)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 1)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 0)
|
||||
|
||||
e = e_it.__next__()
|
||||
self.assertEqual(e.idx(), 2)
|
||||
|
||||
he = self.mesh.halfedge_handle(e, 0)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 2)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 0)
|
||||
he = self.mesh.halfedge_handle(e, 1)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 0)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 2)
|
||||
|
||||
e = e_it.__next__()
|
||||
self.assertEqual(e.idx(), 3)
|
||||
|
||||
he = self.mesh.halfedge_handle(e, 0)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 3)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 0)
|
||||
he = self.mesh.halfedge_handle(e, 1)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 0)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 3)
|
||||
|
||||
e = e_it.__next__()
|
||||
self.assertEqual(e.idx(), 4)
|
||||
|
||||
he = self.mesh.halfedge_handle(e, 0)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 2)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 3)
|
||||
he = self.mesh.halfedge_handle(e, 1)
|
||||
self.assertEqual(self.mesh.to_vertex_handle(he).idx(), 3)
|
||||
self.assertEqual(self.mesh.from_vertex_handle(he).idx(), 2)
|
||||
|
||||
def test_halfedge_iter_skipping(self):
|
||||
# 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
|
||||
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])
|
||||
|
||||
# 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)
|
||||
|
||||
# Run over all halfedges
|
||||
heCounter = 0
|
||||
|
||||
self.mesh.request_face_status()
|
||||
self.mesh.request_vertex_status()
|
||||
self.mesh.request_halfedge_status()
|
||||
|
||||
# Get second edge
|
||||
eh = self.mesh.edge_handle(2)
|
||||
|
||||
# Delete one edge
|
||||
self.mesh.delete_edge(eh)
|
||||
|
||||
# Check setup ( No garbage collection, so nothing should change!)
|
||||
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)
|
||||
|
||||
# =====================================================
|
||||
# Check skipping iterator
|
||||
# =====================================================
|
||||
|
||||
ok_4 = True
|
||||
ok_5 = True
|
||||
|
||||
count = 0
|
||||
|
||||
for he in self.mesh.shalfedges():
|
||||
if he.idx() == 4:
|
||||
ok_4 = False
|
||||
if he.idx() == 5:
|
||||
ok_5 = False
|
||||
count += 1
|
||||
|
||||
self.assertEqual(count, 34)
|
||||
self.assertTrue(ok_4)
|
||||
self.assertTrue(ok_5)
|
||||
|
||||
# =====================================================
|
||||
# Check non skipping iterator
|
||||
# =====================================================
|
||||
|
||||
ok_4 = False
|
||||
ok_5 = False
|
||||
|
||||
count = 0
|
||||
|
||||
for he in self.mesh.halfedges():
|
||||
if he.idx() == 4:
|
||||
ok_4 = True
|
||||
if he.idx() == 5:
|
||||
ok_5 = True
|
||||
count += 1
|
||||
|
||||
self.assertEqual(count, 36)
|
||||
self.assertTrue(ok_4)
|
||||
self.assertTrue(ok_5)
|
||||
|
||||
def test_halfedge_iter_skipping_low_level(self):
|
||||
# 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
|
||||
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])
|
||||
|
||||
# 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)
|
||||
|
||||
# Run over all halfedges
|
||||
heCounter = 0
|
||||
|
||||
self.mesh.request_face_status()
|
||||
self.mesh.request_vertex_status()
|
||||
self.mesh.request_halfedge_status()
|
||||
|
||||
# Get second edge
|
||||
eh = self.mesh.edge_handle(2)
|
||||
|
||||
# Delete one edge
|
||||
self.mesh.delete_edge(eh)
|
||||
|
||||
# Check setup ( No garbage collection, so nothing should change!)
|
||||
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)
|
||||
|
||||
# =====================================================
|
||||
# Try to add low level edge with invalid incidents and
|
||||
# check skipping iterator
|
||||
# =====================================================
|
||||
|
||||
# Add a low level edge without handles
|
||||
eh_test = self.mesh.edge_handle(self.mesh.new_edge(openmesh.VertexHandle(), openmesh.VertexHandle()))
|
||||
|
||||
count = 0
|
||||
found_4 = False
|
||||
found_5 = False
|
||||
found_36 = False
|
||||
found_37 = False
|
||||
|
||||
for he in self.mesh.shalfedges():
|
||||
if he.idx() == 4:
|
||||
found_4 = True
|
||||
if he.idx() == 5:
|
||||
found_5 = True
|
||||
if he.idx() == 36:
|
||||
found_36 = True
|
||||
if he.idx() == 37:
|
||||
found_37 = True
|
||||
count += 1
|
||||
|
||||
self.assertEqual(count, 36)
|
||||
self.assertFalse(found_4)
|
||||
self.assertFalse(found_5)
|
||||
self.assertTrue(found_36)
|
||||
self.assertTrue(found_37)
|
||||
|
||||
# =====================================================
|
||||
# Try to delete one edge with invalid incidents and
|
||||
# check skipping iterator
|
||||
# =====================================================
|
||||
|
||||
# Delete one edge and recheck (Halfedges 4 and 5)
|
||||
self.mesh.delete_edge(eh_test)
|
||||
|
||||
count = 0
|
||||
found_4 = False
|
||||
found_5 = False
|
||||
found_36 = False
|
||||
found_37 = False
|
||||
|
||||
for he in self.mesh.shalfedges():
|
||||
if he.idx() == 4:
|
||||
found_4 = True
|
||||
if he.idx() == 5:
|
||||
found_5 = True
|
||||
if he.idx() == 36:
|
||||
found_36 = True
|
||||
if he.idx() == 37:
|
||||
found_37 = True
|
||||
count += 1
|
||||
|
||||
self.assertEqual(count, 34)
|
||||
self.assertFalse(found_4)
|
||||
self.assertFalse(found_5)
|
||||
self.assertFalse(found_36)
|
||||
self.assertFalse(found_37)
|
||||
|
||||
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__)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(TriMeshIterators)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
103
src/Python/Unittests/test_trimesh_normal_calculations.py
Normal file
103
src/Python/Unittests/test_trimesh_normal_calculations.py
Normal file
@@ -0,0 +1,103 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class Normals(unittest.TestCase):
|
||||
|
||||
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_normal_calculations(self):
|
||||
# Check one Request only vertex normals
|
||||
# Face normals are required for vertex and halfedge normals, so
|
||||
# that prevent access to non existing properties are in place
|
||||
|
||||
self.mesh.request_vertex_normals()
|
||||
self.mesh.request_halfedge_normals()
|
||||
|
||||
# Check blocks
|
||||
self.mesh.update_normals()
|
||||
|
||||
# Request required face normals
|
||||
self.mesh.request_face_normals()
|
||||
|
||||
# Automatically compute all normals
|
||||
# As only vertex normals are requested and no face normals, this will compute nothing.
|
||||
self.mesh.update_normals()
|
||||
|
||||
# Face normals alone
|
||||
self.mesh.update_face_normals()
|
||||
|
||||
# Vertex normals alone (require valid face normals)
|
||||
self.mesh.update_vertex_normals()
|
||||
|
||||
# Halfedge normals alone (require valid face normals)
|
||||
self.mesh.update_halfedge_normals()
|
||||
|
||||
def test_calc_vertex_normal_fast(self):
|
||||
self.mesh.request_vertex_normals()
|
||||
self.mesh.request_halfedge_normals()
|
||||
self.mesh.request_face_normals()
|
||||
|
||||
normal = openmesh.Vec3d()
|
||||
|
||||
self.mesh.calc_vertex_normal_fast(self.vhandle[2], normal)
|
||||
|
||||
def test_calc_vertex_normal_correct(self):
|
||||
self.mesh.request_vertex_normals()
|
||||
self.mesh.request_halfedge_normals()
|
||||
self.mesh.request_face_normals()
|
||||
|
||||
normal = openmesh.Vec3d()
|
||||
|
||||
self.mesh.calc_vertex_normal_correct(self.vhandle[2], normal)
|
||||
|
||||
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)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(Normals)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
129
src/Python/Unittests/test_trimesh_others.py
Normal file
129
src/Python/Unittests/test_trimesh_others.py
Normal file
@@ -0,0 +1,129 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
from math import pi, fabs
|
||||
|
||||
class Others(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.mesh = openmesh.TriMesh()
|
||||
self.vhandle = []
|
||||
|
||||
def test_is_estimated_feature_edge(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(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)
|
||||
|
||||
# ===============================================
|
||||
# Setup complete
|
||||
# ===============================================
|
||||
|
||||
|
||||
# Check one Request only vertex normals
|
||||
# Face normals are required for vertex and halfedge normals, so
|
||||
# that prevent access to non existing properties are in place
|
||||
|
||||
self.mesh.request_vertex_normals()
|
||||
self.mesh.request_halfedge_normals()
|
||||
self.mesh.request_face_normals()
|
||||
|
||||
# Automatically compute all normals
|
||||
# As only vertex normals are requested and no face normals, this will compute nothing.
|
||||
self.mesh.update_normals()
|
||||
|
||||
he = self.mesh.halfedges().__next__()
|
||||
|
||||
self.assertTrue(self.mesh.is_estimated_feature_edge(he, 0.0))
|
||||
self.assertTrue(self.mesh.is_estimated_feature_edge(he, 0.125 * pi))
|
||||
self.assertTrue(self.mesh.is_estimated_feature_edge(he, 0.250 * pi))
|
||||
self.assertTrue(self.mesh.is_estimated_feature_edge(he, 0.375 * pi))
|
||||
self.assertTrue(self.mesh.is_estimated_feature_edge(he, 0.500 * pi))
|
||||
self.assertFalse(self.mesh.is_estimated_feature_edge(he, 0.625 * pi))
|
||||
self.assertFalse(self.mesh.is_estimated_feature_edge(he, 0.750 * pi))
|
||||
self.assertFalse(self.mesh.is_estimated_feature_edge(he, 0.875 * pi))
|
||||
self.assertFalse(self.mesh.is_estimated_feature_edge(he, 1.000 * pi))
|
||||
|
||||
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)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(Others)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
30
src/Python/Unittests/test_vector_type.py
Normal file
30
src/Python/Unittests/test_vector_type.py
Normal file
@@ -0,0 +1,30 @@
|
||||
import unittest
|
||||
import openmesh
|
||||
|
||||
class VectorTest(unittest.TestCase):
|
||||
|
||||
def test_compute_triangle_surface_with_cross_product(self):
|
||||
# vec1
|
||||
# x
|
||||
# |
|
||||
# |
|
||||
# |
|
||||
# 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_abs_test(self):
|
||||
vec1 = openmesh.Vec3d(0.5, 0.5, -0.5)
|
||||
self.assertEqual(vec1.l8_norm(), 0.5)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
suite = unittest.TestLoader().loadTestsFromTestCase(VectorTest)
|
||||
unittest.TextTestRunner(verbosity=2).run(suite)
|
||||
Reference in New Issue
Block a user