Merge pull request #74 from ComFreek/master

Add option to retain face data

Author: Kurt Yoder

README.md

@@ -36,6 +36,7 @@ A more complex example
 * `strict` (Default: `False`) will raise an exception if unsupported features are found in the obj or mtl file
 * `encoding` (Default: `utf-8`) of the obj and mtl file(s)
 * `create_materials` (Default: `False`) will create materials if mtl file is missing or obj file references non-existing materials
+* `collect_faces` (Default: `False`) will collect triangle face data for every mesh. In case faces with more than three vertices are specified they will be triangulated. See the documentation of `ObjParser#consume_faces()` in [`obj.py`](https://github.com/greenmoss/PyWavefront/blob/master/pywavefront/obj.py).
 * `parse` (Default: `True`) decides if parsing should start immediately.
 * `cache` (Default: `False`) writes the parsed geometry to a binary file    for faster loading in the future
 

pywavefront/material.py

@@ -41,7 +41,7 @@
 
 
 class Material(object):
-    def __init__(self, name, is_default=False):
+    def __init__(self, name, is_default=False, has_faces=False):
         """
         Create a new material
         :param name: Name of the material
@@ -55,7 +55,7 @@ def __init__(self, name, is_default=False):
         self.transparency = 1.0
         self.shininess = 0.
         self.optical_density = 1.0
-        # Multiple illumination models are available, per material. These are enumerated as follows: 
+        # Multiple illumination models are available, per material. These are enumerated as follows:
         # 0. Color on and Ambient off
         # 1. Color on and Ambient on
         # 2. Highlight on
@@ -155,7 +155,7 @@ def unset_texture(self):
 class MaterialParser(Parser):
     """Object to parse lines of a materials definition file."""
 
-    def __init__(self, file_name, strict=False, encoding="utf-8", parse=True):
+    def __init__(self, file_name, strict=False, encoding="utf-8", parse=True, collect_faces=False):
         """
         Create a new material parser
         :param file_name: file name and path of obj file to read
@@ -167,13 +167,14 @@ def __init__(self, file_name, strict=False, encoding="utf-8", parse=True):
 
         self.materials = {}
         self.this_material = None
+        self.collect_faces = collect_faces
 
         if parse:
             self.parse()
 
     @auto_consume
     def parse_newmtl(self):
-        self.this_material = Material(self.values[1])
+        self.this_material = Material(self.values[1], has_faces=self.collect_faces)
         self.materials[self.this_material.name] = self.this_material
 
     @auto_consume

pywavefront/mesh.py

@@ -37,10 +37,19 @@ class Mesh(object):
     """This is a basic mesh for drawing using OpenGL. Interestingly, it does
     not contain its own vertices. These are instead drawn via materials."""
 
-    def __init__(self, name=None):
+    def __init__(self, name=None, has_faces=False):
         self.name = name
         self.materials = []
 
+        self.has_faces = has_faces
+
+        # If self.has_faces, this is a list of triangle faces, i.e. triples with vertex indices.
+        #
+        # The original faces have been possibly triangulated if quad or even higher dimensional
+        # faces were specified. See :meth:`ObjParser.consume_faces` for the specific triangulation
+        # algorithm.
+        self.faces = []
+
     def has_material(self, new_material):
         """Determine whether we already have a material of this name."""
         for material in self.materials:

pywavefront/obj.py

@@ -31,6 +31,7 @@
 # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 # POSSIBILITY OF SUCH DAMAGE.
 # ----------------------------------------------------------------------------
+from collections import namedtuple
 import logging
 import os
 import time
@@ -51,7 +52,7 @@ class ObjParser(Parser):
     cache_writer_cls = CacheWriter
 
     def __init__(self, wavefront, file_name, strict=False, encoding="utf-8",
-                 create_materials=False, parse=True, cache=False):
+                 create_materials=False, collect_faces=False, parse=True, cache=False):
         """
         Create a new obj parser
         :param wavefront: The wavefront object
@@ -68,11 +69,11 @@ def __init__(self, wavefront, file_name, strict=False, encoding="utf-8",
         self.mesh = None
         self.material = None
         self.create_materials = create_materials
+        self.collect_faces = collect_faces
         self.cache = cache
         self.cache_loaded = None
 
-        # Stores ALL vertices, normals and texcoords for the entire file
-        self.vertices = []
+        # Stores normals and texcoords for the entire file
         self.normals = []
         self.tex_coords = []
 
@@ -109,7 +110,7 @@ def post_parse(self):
 
     # methods for parsing types of wavefront lines
     def parse_v(self):
-        self.vertices += list(self.consume_vertices())
+        self.wavefront.vertices += list(self.consume_vertices())
 
     def consume_vertices(self):
         """
@@ -213,7 +214,9 @@ def parse_mtllib(self):
             materials = self.material_parser_cls(
                 os.path.join(self.dir, mtllib),
                 encoding=self.encoding,
-                strict=self.strict).materials
+                strict=self.strict,
+                collect_faces=self.collect_faces
+            ).materials
             self.wavefront.mtllibs.append(mtllib)
         except IOError:
             if self.create_materials:
@@ -233,7 +236,7 @@ def parse_usemtl(self):
                 raise PywavefrontException('Unknown material: %s' % name)
 
             # Create a new default material if configured to resolve missing ones
-            self.material = Material(name, is_default=True)
+            self.material = Material(name, is_default=True, has_faces=self.collect_faces)
             self.wavefront.materials[name] = self.material
 
         if self.mesh is not None:
@@ -244,44 +247,82 @@ def parse_usemat(self):
 
     @auto_consume
     def parse_o(self):
-        self.mesh = Mesh(self.values[1])
+        self.mesh = Mesh(self.values[1], has_faces=self.collect_faces)
         self.wavefront.add_mesh(self.mesh)
 
     def parse_f(self):
         # Add default material if not created
         if self.material is None:
-            self.material = Material("default{}".format(len(self.wavefront.materials)), is_default=True)
+            self.material = Material(
+                "default{}".format(len(self.wavefront.materials)),
+                is_default=True,
+                has_faces=self.collect_faces
+            )
             self.wavefront.materials[self.material.name] = self.material
 
         # Support objects without `o` statement
         if self.mesh is None:
-            self.mesh = Mesh()
+            self.mesh = Mesh(has_faces=self.collect_faces)
             self.wavefront.add_mesh(self.mesh)
             self.mesh.add_material(self.material)
 
         self.mesh.add_material(self.material)
 
-        self.material.vertices += list(self.consume_faces())
+        collected_faces = []
+        consumed_vertices = self.consume_faces(collected_faces if self.collect_faces else None)
+        self.material.vertices += list(consumed_vertices)
+
+        if self.collect_faces:
+            self.mesh.faces += list(collected_faces)
 
         # Since list() also consumes StopIteration we need to sanity check the line
         # to make sure the parser advances
         if self.values and self.values[0] == "f":
             self.next_line()
 
-    def consume_faces(self):
+    def consume_faces(self, collected_faces = None):
         """
         Consume all consecutive faces
 
-        If a 4th vertex is specified, we triangulate.
-        In a perfect world we could consume this straight forward and draw using GL_TRIANGLE_FAN.
-        This is however rarely the case..
+        If more than three vertices are specified, we triangulate by the following procedure:
+
+            Let the face have n vertices in the order v_1 v_2 v_3 ... v_n, n >= 3.
+            We emit the first face as usual: (v_1, v_2, v_3). For each remaining vertex v_j,
+            j > 3, we emit (v_j, v_1, v_{j - 1}), e.g. (v_4, v_1, v_3), (v_5, v_1, v_4).
 
-        * If the face is co-planar but concave, then you need to triangulate the face
+        In a perfect world we could consume all vertices straight forward and draw using
+        GL_TRIANGLE_FAN (which exactly matches the procedure above).
+        This is however rarely the case.
+
+        * If the face is co-planar but concave, then you need to triangulate the face.
         * If the face is not-coplanar, you are screwed, because OBJ doesn't preserve enough information
-          to know what tessellation was intended
+          to know what tessellation was intended.
+
+        We always triangulate to make it simple.
 
-        We always triangulate to make it simple
+            :param collected_faces: A list into which all (possibly triangulated) faces will be written in the form
+                                    of triples of the corresponding absolute vertex IDs. These IDs index the list
+                                    self.wavefront.vertices.
+                                    Specify None to prevent consuming faces (and thus saving memory usage).
         """
+
+        # Helper tuple and function
+        Vertex = namedtuple('Vertex', 'idx pos color uv normal')
+        def emit_vertex(vertex):
+            # Just yield all the values except for the index
+            for v in vertex.uv:
+                yield v
+
+            for v in vertex.color:
+                yield v
+
+            for v in vertex.normal:
+                yield v
+
+            for v in vertex.pos:
+                yield v
+
+
         # Figure out the format of the first vertex
         # We raise an exception if any following vertex has a different format
         # NOTE: Order is always v/vt/vn where v is mandatory and vt and vn is optional
@@ -304,11 +345,11 @@ def consume_faces(self):
         # Are we referencing vertex with color info?
         vindex = int(parts[0])
         if vindex < 0:
-            vindex += len(self.vertices)
+            vindex += len(self.wavefront.vertices)
         else:
             vindex -= 1
 
-        vertex = self.vertices[vindex]
+        vertex = self.wavefront.vertices[vindex]
         has_colors = len(vertex) == 6
 
         # Prepare vertex format string
@@ -331,10 +372,8 @@ def consume_faces(self):
         # The first iteration processes the current/first f statement.
         # The loop continues until there are no more f-statements or StopIteration is raised by generator
         while True:
-            v1, vlast = None, None
-
-            # Do we need to triangulate? Each line may contain a varying amount of elements
-            triangulate = (len(self.values) - 1) > 3
+            # The very first vertex, the last encountered and the current one
+            v1, vlast, vcurrent = None, None, None
 
             for i, v in enumerate(self.values[1:]):
                 parts = v.split('/')
@@ -344,50 +383,48 @@ def consume_faces(self):
 
                 # Resolve negative index lookups
                 if v_index < 0:
-                    v_index += len(self.vertices) + 1
+                    v_index += len(self.wavefront.vertices) + 1
 
                 if has_vt and t_index < 0:
                     t_index += len(self.tex_coords) + 1
 
                 if has_vn and n_index < 0:
                     n_index += len(self.normals) + 1
 
-                pos = self.vertices[v_index][0:3] if has_colors else self.vertices[v_index]
-                color = self.vertices[v_index][3:] if has_colors else ()
-                uv = self.tex_coords[t_index] if has_vt else ()
-                normal = self.normals[n_index] if has_vn else ()
-
-                # Just yield all the values
-                for v in uv:
-                    yield v
+                vlast = vcurrent
+                vcurrent = Vertex(
+                    idx = v_index,
+                    pos = self.wavefront.vertices[v_index][0:3] if has_colors else self.wavefront.vertices[v_index],
+                    color = self.wavefront.vertices[v_index][3:] if has_colors else (),
+                    uv = self.tex_coords[t_index] if has_vt else (),
+                    normal = self.normals[n_index] if has_vn else ()
+                )
 
-                for v in color:
-                    yield v
+                yield from emit_vertex(vcurrent)
 
-                for v in normal:
-                    yield v
+                # Triangulation when more than 3 elements are present
+                if i >= 3:
+                    # The current vertex has already been emitted.
+                    # Now just emit the first and the third vertices from the face
+                    yield from emit_vertex(v1)
+                    yield from emit_vertex(vlast)
 
-                for v in pos:
-                    yield v
+                if i == 0:
+                    # Store the first vertex
+                    v1 = vcurrent
 
-                # Triangulation when more than 3 elements is present
-                if triangulate:
+                if (collected_faces is not None) and (i >= 2):
+                    if i == 2:
+                        # Append the first triangle face in usual order (i.e. as specified in the Wavefront file)
+                        collected_faces.append([v1.idx, vlast.idx, vcurrent.idx])
                     if i >= 3:
-                        # Emit vertex 1 and 3 triangulating when a 4th vertex is specified
-                        for v in v1:
-                            yield v
-
-                        for v in vlast:
-                            yield v
-
-                    if i == 0:
-                        # Store the first vertex
-                        v1 = uv + color + normal + pos
-
-                    # Store the last vertex
-                    vlast = uv + color + normal + pos
+                        # Triangulate the remaining part of the face by putting the current, the first
+                        # and the last parsed vertex in that order as a new face.
+                        # This order coincides deliberately with the order from vertex yielding above.
+                        collected_faces.append([vcurrent.idx, v1.idx, vlast.idx])
 
             # Break out of the loop when there are no more f statements
+
             try:
                 self.next_line()
             except StopIteration:

pywavefront/wavefront.py

@@ -42,7 +42,16 @@ class Wavefront(object):
     parser_cls = ObjParser
 
     """Import a wavefront .obj file."""
-    def __init__(self, file_name, strict=False, encoding="utf-8", create_materials=False, parse=True, cache=False):
+    def __init__(
+        self,
+        file_name,
+        strict=False,
+        encoding="utf-8",
+        create_materials=False,
+        collect_faces=False,
+        parse=True,
+        cache=False
+    ):
         """
         Create a Wavefront instance
         :param file_name: file name and path of obj file to read
@@ -55,6 +64,7 @@ def __init__(self, file_name, strict=False, encoding="utf-8", create_materials=F
         self.mtllibs = []
         self.materials = {}
         self.meshes = {}        # Name mapping
+        self.vertices = []
         self.mesh_list = []     # Also includes anonymous meshes
 
         self.parser = self.parser_cls(
@@ -63,6 +73,7 @@ def __init__(self, file_name, strict=False, encoding="utf-8", create_materials=F
             strict=strict,
             encoding=encoding,
             create_materials=create_materials,
+            collect_faces=collect_faces,
             parse=parse,
             cache=cache)
 

test/arbitrary-faces.obj

@@ -0,0 +1,29 @@
+# Model with faces with vertex counts >= 3
+
+o triangleOnly
+v 0.01 0.02 0.03
+v 0.04 0.05 0.06
+v 0.07 0.08 0.09
+v 0.11 0.12 0.13
+f 2 1 3
+
+o quadOnly
+v 1.0 0.0 1.0
+v -1.0 0.0 1.0
+v 1.0 0.0 -1.0
+v -1.0 0.0 -1.0
+f 5 6 7 8
+f 6 5 7 8
+f 8 7 5 6
+
+o arbitrary
+v 1.0 0.0 1.0
+v -1.0 0.0 1.0
+v 1.0 0.0 -1.0
+v -1.0 0.0 -1.0
+v -1.0 1.0 -1.0
+v -1.0 1.0 -2.0
+f 9 10 11 12
+f 12 9 10 11 13
+f 13 10 11 9 12 14
+f 14 12 10