root/trunk/RBRapier/RBRapier/Tools/Geometry/Synthesis/VertexNormals.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 weakref
import Numeric
from RBRapier.Tools.Vector import Vector3
from RBFoundation.Aspects.FlyweightGroup import FlyweightGroupObject

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

class Vertex(FlyweightGroupObject):
    def __init__(self, idx):
        self.idx = idx
        self.Normals = {}

    def IntegrateNormal(self, normal, cosToler=2.):
        if cosToler is not None:
            for idx, (value, blendable) in self.Normals.iteritems():
                if not blendable: continue
                cosAngle = normal.Dot(value)
                #if not (-1.000001 <= cosAngle <= 1.000001):
                #    print cosAngle
                assert -1.000001 <= cosAngle <= 1.000001
                #divisor = abs(value) * abs(normal)
                #cosAngle = normal.Dot(value) / divisor
                #try:
                #    print 180./Numeric.pi * Numeric.arccos(cosAngle)
                #except ValueError:
                #    print "ValueError", cosAngle
                if cosAngle >= cosToler:
                    # Found one within tolerance... average them
                    self.Normals[idx] = ((normal + value).Normalize(), blendable)
                    return idx
            blendable = 1
        else: blendable = 0

        # Well, let's make a new normal then
        if not self.Normals: idx = self.idx
        else: idx = self.owner._GetNextValue()
        self.Normals[idx] = normal.Normalize(), blendable
        return idx

    def SetResults(self, VertexData, NormalData):
        srcVertex = self.owner.VertexData[self.idx]
        for idx, (normal, blendable) in self.Normals.iteritems():
            VertexData[idx] = srcVertex
            NormalData[idx] = normal.Normalize().asarray()

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class VertexNormalSynthesisMgr(object):
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Public Methods 
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def __init__(self, VertexData, tolerance=None):
        self._VertexClass = Vertex.FlyweightGroup('VertexNormalSynthesisMgr', owner=weakref.proxy(self))
        self.VertexData = VertexData
        self.NextVertexIdx = len(VertexData)
        self.Vertices = [self._VertexClass(i) for i in xrange(self.NextVertexIdx)]
        self.SetTolerance(tolerance)

    def SetTolerance(self, tolerance):
        if tolerance is None: self._cosToler = None
        else: self._cosToler = Numeric.cos(tolerance)
        
    def GetResultantArrays(self):
        defval = (0.,0.,0.)
        self.NormalData = [defval for i in xrange(self.NextVertexIdx)]
        self.VertexData.extend(self.NormalData[len(self.VertexData):])
        for vertex in self.Vertices:
            vertex.SetResults(self.VertexData, self.NormalData)
        return self.VertexData, self.NormalData

    def VisitTriangle(self, vi0, vi1, vi2):
        if vi0==vi1 or vi1==vi2 or vi2==vi0:
            print "Degenerate triangle found"
            return None
        normal = self._CalculateNormal(vi0, vi1, vi2)
        if normal is None:
            return None
        else:
            vi0 = self.Vertices[vi0].IntegrateNormal(normal, self._cosToler)
            vi1 = self.Vertices[vi1].IntegrateNormal(normal, self._cosToler)
            vi2 = self.Vertices[vi2].IntegrateNormal(normal, self._cosToler)
            return vi0, vi1, vi2

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

    def _GetNextValue(self):
        result = self.NextVertexIdx
        self.NextVertexIdx = result + 1
        return result

    def _CalculateNormal(self, vi0, vi1, vi2):
        vector0 = Vector3(self.VertexData[vi0])
        e01 = (Vector3(self.VertexData[vi1]) - vector0).Normalize()
        e02 = (Vector3(self.VertexData[vi2]) - vector0).Normalize()
        normal = e01.Cross3(e02)
        if normal.Magnitude(0) <= 1e-9: 
            return e01
        else: 
            return normal.Normalize()

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Optimization
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

try: import psyco
except ImportError: pass
else:
    psyco.bind(Vertex)
    psyco.bind(VertexNormalSynthesisMgr)