# DAVIDSTUTZ

Check out the latest superpixel benchmark — Superpixel Benchmark (2016) — and let me know your opinion! @david_stutz
13thAPRIL2017

## Reading and Writing `.off` Files in Python

Reading and writing triangular meshes from `.off` files in Python.

`off_io.py`
```#!/usr/bin/env python
"""
"""

import os

def write_off(file, vertices, faces):
"""
Writes the given vertices and faces to OFF.

:param vertices: vertices as tuples of (x, y, z) coordinates
:type vertices: [(float)]
:param faces: faces as tuples of (num_vertices, vertex_id_1, vertex_id_2, ...)
:type faces: [(int)]
"""

assert len(vertices) > 0
assert len(faces) > 0

with open(file, 'w') as fp:
fp.write('OFF\n')
fp.write(str(len(vertices)) + ' ' + str(len(faces)) + ' 0\n')

for vertex in vertices:
assert len(vertex) == 3
fp.write(str(vertex[0]) + ' ' + str(vertex[1]) + ' ' + str(vertex[2]) + '\n')

for face in faces:
assert len(face) > 2

for i in range(len(face)):
fp.write(str(face[i]))
if i < len(face) - 1:
fp.write(' ')

fp.write('\n')

"""
Reads vertices and faces from an off file.

:param file: path to file to read
:type file: str
:return: vertices and faces as lists of tuples
:rtype: [(float)], [(int)]
"""

assert os.path.exists(file)

with open(file, 'r') as fp:
lines = [line.strip() for line in lines]

assert lines[0] == 'OFF'

parts = lines[1].split(' ')
assert len(parts) == 3

num_vertices = int(parts[0])
assert num_vertices > 0

num_faces = int(parts[1])
assert num_faces > 0

vertices = []
for i in range(num_vertices):
vertex = lines[2 + i].split(' ')
vertex = [float(point) for point in vertex]
assert len(vertex) == 3

vertices.append(vertex)

faces = []
for i in range(num_faces):
face = lines[2 + num_vertices + i].split(' ')
face = [int(index) for index in face]

assert face[0] == len(face) - 1
for index in face:
assert index >= 0 and index < num_vertices

assert len(face) > 1

faces.append(face)

return vertices, faces
```

What is your opinion on the code snippet? Is it working? Let me know your thoughts in the comments below or using the following platforms: