root/trunk/RBRapier/RBRapier/Formats/Wavefront/Loader.py

#!/usr/bin/env python
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
##~ License 
##~ 
##- The RuneBlade Foundation library is intended to ease some 
##- aspects of writing intricate Jabber, XML, and User Interface (wxPython, etc.) 
##- applications, while providing the flexibility to modularly change the 
##- architecture. Enjoy.
##~ 
##~ Copyright (C) 2002  TechGame Networks, LLC.
##~ 
##~ This library is free software; you can redistribute it and/or
##~ modify it under the terms of the BSD style License as found in the 
##~ LICENSE file included with this distribution.
##~ 
##~ TechGame Networks, LLC can be reached at:
##~ 3578 E. Hartsel Drive #211
##~ Colorado Springs, Colorado, USA, 80920
##~
##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Imports 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

import os

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Definitions 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class WavefrontOBJLoader(object):
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Constants / Variables / Etc. 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    RaiseMissingElements = 0
    WarnMissingElements = 0

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Public Methods 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def ReadFormat(self, WavefrontOBJFile):
        self.Name = None
        self.Vertices = []
        self.Normals = []
        self.TexCoords = []
        self.Groups = []

        self._FilePath = os.path.split(WavefrontOBJFile.name)[0]
        self._strGroupName(['default'])

        CommandTable = {
            'o': self._strSetObjectName,

            'v': self._strAddVertex,
            'vn': self._strAddNormal,
            'vt': self._strAddTextureCoord,

            'p': self._strAddPoint,
            'l': self._strAddLine,
            'f': self._strAddFace,

            'g': self._strGroupName,
            'group': self._strGroupName,
            #'s': self._strGroupSmoothing,
            #'mg': self._strGroupMerge,

            #'mtllib': self._strMaterialLibrary,
            #'usemtl': self._strUseMaterial,

            #'usemap': self._strUseTextureMap,
            }

        Line, LineNumber = '', 0
        for PartialLine in WavefrontOBJFile:
            LineNumber += 1
            Line += PartialLine.strip()
            if not Line or Line[0] == '#': 
                Line = ''
                continue # Comment -- move on
            if Line[-1] == '\\':
                Line = Line[:-1]
                continue # line continuation -- get the rest of it
            Line = Line.split()
            Command, Args = Line[0], Line[1:]
            try: 
                ex = CommandTable[Command]
            except KeyError:
                if self.RaiseMissingElements:
                    raise NotImplemented, "Unknown Wavefront command %r (%s<%d>)" % (' '.join(Line), WavefrontOBJFile.name, LineNumber)
                elif self.WarnMissingElements:
                    print "%s<%d>: Wavefront command not supported: %r" % (WavefrontOBJFile.name, LineNumber, ' '.join(Line))
            else:
                ex(Args)
            Line = ''

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Protected Methods 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    OffsetIndicesDetected = 0
    def _DetectOffsetIndices(self, indices):
        if not self.OffsetIndicesDetected:
            i0 = indices[0]
            for i in [x for x in indices[1:] if x is not None]:
                if i != i0:
                    self._ffsetIndicesDetected = 1

    def _ConvertWavefrontIndex(self, x):
        if x: return int(x) - 1
        else: return None

    def _strSetObjectName(self, Args):
        self.Name = ' '.join(Args)

    def _strGroupName(self, Args):
        class GroupObject(object): pass
        self.CurrentGroup = GroupObject()
        self.CurrentGroup.Names = Args
        self.CurrentGroup.Points = []
        self.CurrentGroup.Lines = []
        self.CurrentGroup.Faces = []
        self.Groups.append(self.CurrentGroup)
    def _strGroupSmoothing(self, Args):
        self.CurrentGroup.Smoothing = Args
    #def _strGroupMerge(self, Args):
    #    print "Group Merge:", Args

    def _strAddVertex(self, Args):
        self.Vertices.append(map(float, Args))
    def _strAddTextureCoord(self, Args):
        self.TexCoords.append(map(float, Args))
    def _strAddNormal(self, Args):
        self.Normals.append(map(float, Args))

    def _strAddPoint(self, Args):
        VertexIndices = [self._ConvertWavefrontIndex(x) for x in Args]
        self.CurrentGroup.Points.extend(VertexIndices)

    def _strAddLine(self, Args):
        LineEntry = []
        for VT in Args:
            VT = [self._ConvertWavefrontIndex(x) for x in VT.split('/')]
            self._DetectOffsetIndices(VT)
            if LineEntry and (len(VT) != len(LineEntry[-1])):
                raise ValueError, "All line points must have the same number of components"
            LineEntry.append(VT)
        self.CurrentGroup.Lines.append(LineEntry)

    def _strAddFace(self, Args):
        FaceEntry = []
        for VTN in Args:
            VTN = [self._ConvertWavefrontIndex(x) for x in VTN.split('/')]
            self._DetectOffsetIndices(VTN)
            if FaceEntry and (len(VTN) != len(FaceEntry[-1])):
                raise ValueError, "All face points must have the same number of components"
            FaceEntry.append(tuple(VTN))
        self.CurrentGroup.Faces.append(FaceEntry)

    #def _strMaterialLibrary(self, Args):
    #    for MaterialFileName in Args:
    #        MaterialFile = file(os.path.join(self._FilePath, MaterialFileName), 'r')
    #        Material = WavefrontMaterialFile(self.RaiseMissingElements, self.WarnMissingElements)
    #        self._Object.MaterialLibrary.update(Material.ReadFormat(MaterialFile))

    #def _strUseMaterial(self, Args):
    #    for MaterialName in Args:
    #        material =  self._Object.MaterialLibrary.get(MaterialName, None)
    #        if material:
    #            self._Group.Materials.append(material)

    #def _strUseTextureMap(self, Args):
    #    print "Use Texture Map:", Args


#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Testing 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

if __name__=='__main__':
    print "Testing..."
    test = WavefrontOBJLoader()
    obj = test.ReadFormat(open('data/shuttle.obj', 'r'))
    obj = test.ReadFormat(open('data/cessna.obj', 'r'))
    obj = test.ReadFormat(open('data/oldtree.obj', 'r'))
    obj = test.ReadFormat(open('data/porsche.obj', 'r'))
    obj = test.ReadFormat(open('data/soccerball.obj', 'r'))
    obj = test.ReadFormat(open('data/sword.obj', 'r'))
    print "Test complete."