def test_import_mesh(self, with_normals, with_materials, expected_vertices,
expected_faces, expected_uvs, expected_face_uvs_idx,
expected_vertex_normals, expected_face_normals,
expected_materials):
outputs = obj.import_mesh(os.path.join(SIMPLE_DIR, 'model.obj'),
with_materials=with_materials,
with_normals=with_normals,
error_handler=obj.skip_error_handler)
assert torch.equal(outputs.vertices, expected_vertices)
assert torch.equal(outputs.faces, expected_faces)
if with_materials:
assert torch.allclose(outputs.uvs, expected_uvs)
assert torch.equal(outputs.face_uvs_idx, expected_face_uvs_idx)
assert len(outputs.materials) == len(expected_materials)
for outputs_material, expected_material in zip(
outputs.materials, expected_materials):
assert outputs_material.keys() == expected_material.keys()
for property_name, expected_property_val in expected_material.items(
):
assert torch.allclose(outputs_material[property_name],
expected_property_val)
assert torch.equal(outputs.materials_order,
torch.LongTensor([[0, 0], [1, 1]]))
else:
assert outputs.materials is None
assert outputs.materials_order is None
if with_normals:
assert torch.equal(outputs.vertex_normals, expected_vertex_normals)
assert torch.equal(outputs.face_normals, expected_face_normals)
else:
assert outputs.vertex_normals is None
assert outputs.face_normals is None
def test_large_obj(self, with_materials, with_normals,
expected_large_values):
outputs = obj.import_mesh(os.path.join(ROOT_DIR, "model.obj"),
with_materials=with_materials,
with_normals=with_normals)
assert outputs.vertices.shape == (
expected_large_values['num_vertices'], 3)
assert outputs.faces.shape == (expected_large_values['num_faces'], 3)
if with_materials:
assert outputs.uvs.shape == (expected_large_values['num_uvs'], 2)
assert outputs.face_uvs_idx.shape == (
expected_large_values['num_faces'], 3)
assert len(
outputs.materials) == expected_large_values['num_materials']
assert outputs.materials_order.shape == (
expected_large_values['num_face_groups'], 2)
else:
assert outputs.uvs is None
assert outputs.face_uvs_idx is None
assert outputs.materials is None
assert outputs.materials_order is None
if with_normals:
assert outputs.vertex_normals.shape == (
expected_large_values['num_normals'], 3)
assert outputs.face_normals.shape == (
expected_large_values['num_faces'], 3)
else:
assert outputs.vertex_normals is None
assert outputs.face_normals is None
def mesh_alt():
cur_dir = os.path.dirname(os.path.realpath(__file__))
obj_mesh = obj.import_mesh(os.path.join(cur_dir, os.pardir, os.pardir,
os.pardir, 'samples/model.obj'),
with_normals=True,
with_materials=True,
error_handler=obj.skip_error_handler)
return obj_mesh
def test_warn_import_mesh(self, with_normals):
with pytest.warns(
UserWarning,
match=
fr"Failed to load material at path '{os.path.join(SIMPLE_DIR, 'model.mtl')}':\n"
fr"\[Errno 21\] Is a directory: '{os.path.join(SIMPLE_DIR, '.')}'"
):
outputs = obj.import_mesh(os.path.join(SIMPLE_DIR, "model.obj"),
with_materials=True,
with_normals=with_normals,
error_handler=obj.skip_error_handler)
def test_error_import_mesh(self, with_normals):
with pytest.raises(
obj.MaterialLoadError,
match=
fr"Failed to load material at path '{os.path.join(SIMPLE_DIR, 'model.mtl')}':\n"
fr"\[Errno 21\] Is a directory: '{os.path.join(SIMPLE_DIR, '.')}'"
):
outputs = obj.import_mesh(os.path.join(SIMPLE_DIR, 'model.obj'),
with_materials=True,
with_normals=with_normals,
error_handler=obj.default_error_handler)
def test_adjacency_consistent(device, dtype):
test_mesh = obj.import_mesh(os.path.join(ROOT_DIR, 'model.obj'))
vertices = test_mesh.vertices
faces = test_mesh.faces
num_vertices = vertices.shape[0]
sparse = mesh.adjacency_matrix(num_vertices, faces)
sparse_to_dense = sparse.to_dense()
dense = mesh.adjacency_matrix(num_vertices, faces, sparse=False)
assert torch.equal(sparse_to_dense, dense)
def get_data(self, index):
obj_location = self.paths[index] / 'models/model_normalized.obj'
mesh = import_mesh(str(obj_location),
with_materials=self.with_materials,
error_handler=ignore_error_handler)
return mesh
def test_warn_import_mesh(self, with_normals):
with pytest.warns(UserWarning):
outputs = obj.import_mesh(os.path.join(SIMPLE_DIR, "model.obj"),
with_materials=True,
with_normals=with_normals,
error_handler=obj.skip_error_handler)
def test_error_import_mesh(self, with_normals):
with pytest.raises(obj.MaterialLoadError):
outputs = obj.import_mesh(os.path.join(SIMPLE_DIR, 'model.obj'),
with_materials=True,
with_normals=with_normals,
error_handler=obj.default_error_handler)
def get_data(self, index):
obj_location = self.paths[index]
mesh = import_mesh(str(obj_location),
error_handler=ignore_error_handler)
return mesh
def get_data(self, index):
obj_location = self.paths[index] / 'model.obj'
mesh = import_mesh(str(obj_location))
return mesh
