Add a config class

[vrm.git] / vrm.py

diff --git a/vrm.py b/vrm.py
index 69099c4..fc7cb5d 100755 (executable)
--- a/vrm.py
+++ b/vrm.py
@@ -1,13 +1,13 @@
 #!BPY
 """
 Name: 'VRM'
 #!BPY
 """
 Name: 'VRM'

-Blender: 241
-Group: 'Export'
-Tooltip: 'Vector Rendering Method Export Script'
+Blender: 242
+Group: 'Render'
+Tooltip: 'Vector Rendering Method script'

 """
 
 __author__ = "Antonio Ospite"
 """
 
 __author__ = "Antonio Ospite"

-__url__ = ["blender"]
+__url__ = ["http://vrm.projects.blender.org"]

 __version__ = "0.3"
 
 __bpydoc__ = """\
 __version__ = "0.3"
 
 __bpydoc__ = """\


@@ -43,18 +43,23 @@ __bpydoc__ = """\
 # 
 # Things TODO for a next release:
 #   - Switch to the Mesh structure, should be considerably faster
 # 
 # Things TODO for a next release:
 #   - Switch to the Mesh structure, should be considerably faster

-#    (partially done, but cannot sort faces, yet)
+#    (partially done, but with Mesh we cannot sort faces, yet)

 #   - Use a better depth sorting algorithm
 #   - Review how selections are made (this script uses selection states of
 #     primitives to represent visibility infos)
 #   - Use a better depth sorting algorithm
 #   - Review how selections are made (this script uses selection states of
 #     primitives to represent visibility infos)

-#   - Implement Clipping and do handle object intersections
-#   - Implement Edge Styles (silhouettes, contours, etc.)
+#   - Implement clipping of primitives and do handle object intersections.
+#     (for now only clipping for whole objects is supported).
+#   - Implement Edge Styles (silhouettes, contours, etc.) (partially done).

 #   - Implement Edge coloring
 #   - Use multiple lighting sources in color calculation
 #   - Implement Edge coloring
 #   - Use multiple lighting sources in color calculation

-#   - Implement Shading Styles?
-#   - Use another representation for the 2D projection? 
+#   - Implement Shading Styles? (for now we use Flat Shading).
+#   - Use a data structure other than Mesh to represent the 2D image? 

 #     Think to a way to merge adjacent polygons that have the same color.
 #     Think to a way to merge adjacent polygons that have the same color.

-#   - Add other Vector Writers.
+#     Or a way to use paths for silhouettes and contours.
+#   - Add Vector Writers other that SVG.
+#   - Consider SMIL for animation handling instead of ECMA Script? (Firefox do
+#     not support SMIL for animations)
+#   - FIX the issue with negative scales in object tranformations!

 #
 # ---------------------------------------------------------------------
 #
 #
 # ---------------------------------------------------------------------
 #


@@ -74,18 +79,109 @@ from math import *
 
 
 # Some global settings
 
 
 # Some global settings

-PRINT_POLYGONS     = True
-PRINT_EDGES        = False
-SHOW_HIDDEN_EDGES  = False

 
 

-EDGES_WIDTH = 0.5
+class config:
+    polygons = dict()
+    polygons['FILL'] = True
+    polygons['STYLE'] = None
+    # Hidden to the user for now
+    polygons['EXPANSION_TRICK'] = True

 
 

-POLYGON_EXPANSION_TRICK = True
+    edges = dict()
+    edges['SHOW'] = True
+    edges['SHOW_HIDDEN'] = False
+    edges['STYLE'] = 'silhouette'
+    edges['WIDTH'] = 2

 
 

-RENDER_ANIMATION = False
+    output = dict()
+    output['FORMAT'] = 'SVG'
+    output['ANIMATION'] = False
+    output['MERGED_OBJECTS'] = True
+
+
+
+# ---------------------------------------------------------------------
+#
+## Utility Mesh class
+#
+# ---------------------------------------------------------------------
+class MeshUtils:
+
+    def getEdgeAdjacentFaces(edge, mesh):
+        """Get the faces adjacent to a given edge.
+
+        There can be 0, 1 or more (usually 2) faces adjacent to an edge.
+        """
+        adjface_list = []
+
+        for f in mesh.faces:
+            if (edge.v1 in f.v) and (edge.v2 in f.v):
+                adjface_list.append(f)
+
+        return adjface_list
+
+    def isVisibleEdge(e, mesh):
+        """Normal edge selection rule.
+
+        An edge is visible if _any_ of its adjacent faces is selected.
+        Note: if the edge has no adjacent faces we want to show it as well,
+        useful for "edge only" portion of objects.
+        """
+
+        adjacent_faces = MeshUtils.getEdgeAdjacentFaces(e, mesh)
+
+        if len(adjacent_faces) == 0:
+            return True
+
+        selected_faces = [f for f in adjacent_faces if f.sel]
+
+        if len(selected_faces) != 0:
+            return True
+        else:
+            return False
+
+    def isSilhouetteEdge(e, mesh):
+        """Silhuette selection rule.
+
+        An edge is a silhuette edge if it is shared by two faces with
+        different selection status or if it is a boundary edge of a selected
+        face.
+        """
+
+        adjacent_faces = MeshUtils.getEdgeAdjacentFaces(e, mesh)
+
+        if ((len(adjacent_faces) == 1 and adjacent_faces[0].sel == 1) or
+            (len(adjacent_faces) == 2 and
+                adjacent_faces[0].sel != adjacent_faces[1].sel)
+            ):
+            return True
+        else:
+            return False
+    
+    def toonShading(u):
+
+        levels = 2
+        texels = 2*levels - 1
+        map = [0.0] + [(i)/float(texels-1) for i in range(1, texels-1) ] + [1.0]
+        
+        v = 1.0
+        for i in range(0, len(map)-1):
+            pivot = (map[i]+map[i+1])/2.0
+            j = int(u>pivot)
+
+            v = map[i+j]
+
+            if v<map[i+1]:
+                return v
+
+        return v
+
+
+    getEdgeAdjacentFaces = staticmethod(getEdgeAdjacentFaces)
+    isVisibleEdge = staticmethod(isVisibleEdge)
+    isSilhouetteEdge = staticmethod(isSilhouetteEdge)
+    toonShading = staticmethod(toonShading)

 
 

-# Do not work for now!
-OPTIMIZE_FOR_SPACE = False

 
 
 # ---------------------------------------------------------------------
 
 
 # ---------------------------------------------------------------------


@@ -129,7 +225,6 @@ class Projector:
         else:
             mP = self._calcPerspectiveMatrix(fovy, aspect, near, far) 
         
         else:
             mP = self._calcPerspectiveMatrix(fovy, aspect, near, far) 
         

-

         # View transformation
         cam = Matrix(cameraObj.getInverseMatrix())
         cam.transpose() 
         # View transformation
         cam = Matrix(cameraObj.getInverseMatrix())
         cam.transpose() 


@@ -214,9 +309,10 @@ class Projector:
         return m
 
 
         return m
 
 

+

 # ---------------------------------------------------------------------
 #
 # ---------------------------------------------------------------------
 #

-## 2DObject representation class
+## 2D Object representation class

 #
 # ---------------------------------------------------------------------
 
 #
 # ---------------------------------------------------------------------
 


@@ -293,10 +389,10 @@ class SVGVectorWriter(VectorWriter):
     """A concrete class for writing SVG output.
     """
 
     """A concrete class for writing SVG output.
     """
 

-    def __init__(self, file):
+    def __init__(self, fileName):

         """Simply call the parent Contructor.
         """
         """Simply call the parent Contructor.
         """

-        VectorWriter.__init__(self, file)
+        VectorWriter.__init__(self, fileName)

 
 
     ##
 
 
     ##


@@ -314,6 +410,9 @@ class SVGVectorWriter(VectorWriter):
         """
         self._printFooter()
 
         """
         self._printFooter()
 

+        # remember to call the close method of the parent
+        VectorWriter.close(self)
+

         
     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
             showHiddenEdges=False):
         
     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
             showHiddenEdges=False):


@@ -334,6 +433,7 @@ class SVGVectorWriter(VectorWriter):
         self.file.write("<g id=\"frame%d\" style=\"%s\">\n" %
                 (framenumber, framestyle) )
 
         self.file.write("<g id=\"frame%d\" style=\"%s\">\n" %
                 (framenumber, framestyle) )
 

+

         for obj in Objects:
 
             if(obj.getType() != 'Mesh'):
         for obj in Objects:
 
             if(obj.getType() != 'Mesh'):


@@ -443,7 +543,7 @@ class SVGVectorWriter(VectorWriter):
 
         for face in mesh.faces:
             if not face.sel:
 
         for face in mesh.faces:
             if not face.sel:

-                continue
+               continue

 
             self.file.write("<polygon points=\"")
 
 
             self.file.write("<polygon points=\"")
 


@@ -459,9 +559,9 @@ class SVGVectorWriter(VectorWriter):
             # TODO: the average of vetrex colors?
             if face.col:
                 fcol = face.col[0]
             # TODO: the average of vetrex colors?
             if face.col:
                 fcol = face.col[0]

-                color = [fcol.r, fcol.g, fcol.b]
+                color = [fcol.r, fcol.g, fcol.b, fcol.a]

             else:
             else:

-                color = [255, 255, 255]
+                color = [255, 255, 255, 255]

 
             # use the stroke property to alleviate the "adjacent edges" problem,
             # we simulate polygon expansion using borders,
 
             # use the stroke property to alleviate the "adjacent edges" problem,
             # we simulate polygon expansion using borders,


@@ -469,10 +569,20 @@ class SVGVectorWriter(VectorWriter):
             stroke_col = color
             stroke_width = 0.5
 
             stroke_col = color
             stroke_width = 0.5
 

-            self.file.write("\tstyle=\"fill:rgb("+str(color[0])+","+str(color[1])+","+str(color[2])+");")
-            if POLYGON_EXPANSION_TRICK:
-                self.file.write(" stroke:rgb("+str(stroke_col[0])+","+str(stroke_col[1])+","+str(stroke_col[2])+");")
-                self.file.write(" stroke-width:"+str(stroke_width)+";\n")
+            # Convert the color to the #RRGGBB form
+            str_col = "#%02X%02X%02X" % (color[0], color[1], color[2])
+
+            # Handle transparent polygons
+            opacity_string = ""
+            if color[3] != 255:
+                opacity = float(color[3])/255.0
+                opacity_string = " fill-opacity: %g; stroke-opacity: %g; opacity: 1;" % (opacity, opacity)
+
+            self.file.write("\tstyle=\"fill:" + str_col + ";")
+            self.file.write(opacity_string)
+            if config.polygons['EXPANSION_TRICK']:
+                self.file.write(" stroke:" + str_col + ";")
+                self.file.write(" stroke-width:" + str(stroke_width) + ";\n")

                 self.file.write(" stroke-linecap:round;stroke-linejoin:round")
             self.file.write("\"/>\n")
 
                 self.file.write(" stroke-linecap:round;stroke-linejoin:round")
             self.file.write("\"/>\n")
 


@@ -491,8 +601,7 @@ class SVGVectorWriter(VectorWriter):
             
             hidden_stroke_style = ""
             
             
             hidden_stroke_style = ""
             

-            # Consider an edge selected if both vertices are selected
-            if e.v1.sel == 0 or e.v2.sel == 0:
+            if e.sel == 0:

                 if showHiddenEdges == False:
                     continue
                 else:
                 if showHiddenEdges == False:
                     continue
                 else:


@@ -519,6 +628,19 @@ class SVGVectorWriter(VectorWriter):
 #
 # ---------------------------------------------------------------------
 
 #
 # ---------------------------------------------------------------------
 

+# A dictionary to collect all the different edge styles and their edge
+# selection criteria
+edgeSelectionStyles = {
+        'normal': MeshUtils.isVisibleEdge,
+        'silhouette': MeshUtils.isSilhouetteEdge
+        }
+
+# A dictionary to collect the supported output formats
+outputWriters = {
+        'SVG': SVGVectorWriter,
+        }
+
+

 class Renderer:
     """Render a scene viewed from a given camera.
     
 class Renderer:
     """Render a scene viewed from a given camera.
     


@@ -549,13 +671,22 @@ class Renderer:
         # Render from the currently active camera 
         self.cameraObj = self._SCENE.getCurrentCamera()
 
         # Render from the currently active camera 
         self.cameraObj = self._SCENE.getCurrentCamera()
 

+        # Get a projector for this camera.
+        # NOTE: the projector wants object in world coordinates,
+        # so we should remember to apply modelview transformations
+        # _before_ we do projection transformations.
+        self.proj = Projector(self.cameraObj, self.canvasRatio)
+

         # Get the list of lighting sources
         obj_lst = self._SCENE.getChildren()
         self.lights = [ o for o in obj_lst if o.getType() == 'Lamp']
 
         # Get the list of lighting sources
         obj_lst = self._SCENE.getChildren()
         self.lights = [ o for o in obj_lst if o.getType() == 'Lamp']
 

+        # When there are no lights we use a default lighting source
+        # that have the same position of the camera

         if len(self.lights) == 0:
             l = Lamp.New('Lamp')
             lobj = Object.New('Lamp')
         if len(self.lights) == 0:
             l = Lamp.New('Lamp')
             lobj = Object.New('Lamp')

+            lobj.loc = self.cameraObj.loc

             lobj.link(l) 
             self.lights.append(lobj)
 
             lobj.link(l) 
             self.lights.append(lobj)
 


@@ -568,7 +699,7 @@ class Renderer:
         """Render picture or animation and write it out.
         
         The parameters are:
         """Render picture or animation and write it out.
         
         The parameters are:

-            - a Vector writer object than will be used to output the result.
+            - a Vector writer object that will be used to output the result.

             - a flag to tell if we want to render an animation or only the
               current frame.
         """
             - a flag to tell if we want to render an animation or only the
               current frame.
         """


@@ -591,12 +722,25 @@ class Renderer:
         for f in range(startFrame, endFrame+1):
             context.currentFrame(f)
 
         for f in range(startFrame, endFrame+1):
             context.currentFrame(f)
 

-            renderedScene = self.doRenderScene(self._SCENE)
+            # Use some temporary workspace, a full copy of the scene
+            inputScene = self._SCENE.copy(2)
+
+            print "Before"
+
+            try:
+                renderedScene = self.doRenderScene(inputScene)
+            except:
+                self._SCENE.makeCurrent()
+                Scene.unlink(inputScene)
+                del inputScene
+

             outputWriter.printCanvas(renderedScene,
             outputWriter.printCanvas(renderedScene,

-                    doPrintPolygons = PRINT_POLYGONS,
-                    doPrintEdges    = PRINT_EDGES,
-                    showHiddenEdges = SHOW_HIDDEN_EDGES)
+                    doPrintPolygons = config.polygons['FILL'],
+                    doPrintEdges    = config.edges['SHOW'],
+                    showHiddenEdges = config.edges['SHOW_HIDDEN'])

             
             

+            print "After"
+

             # clear the rendered scene
             self._SCENE.makeCurrent()
             Scene.unlink(renderedScene)
             # clear the rendered scene
             self._SCENE.makeCurrent()
             Scene.unlink(renderedScene)


@@ -607,70 +751,63 @@ class Renderer:
         context.currentFrame(currentFrame)
 
 
         context.currentFrame(currentFrame)
 
 

-    def doRenderScene(self, inputScene):
+    def doRenderScene(self, workScene):

         """Control the rendering process.
         
         Here we control the entire rendering process invoking the operation
         needed to transform and project the 3D scene in two dimensions.
         """
         
         """Control the rendering process.
         
         Here we control the entire rendering process invoking the operation
         needed to transform and project the 3D scene in two dimensions.
         """
         

-        # Use some temporary workspace, a full copy of the scene
-        workScene = inputScene.copy(2)
+        # global processing of the scene

 
 

-        # Get a projector for this scene.
-        # NOTE: the projector wants object in world coordinates,
-        # so we should apply modelview transformations _before_
-        # projection transformations
-        proj = Projector(self.cameraObj, self.canvasRatio)
+        self._doConvertGeometricObjToMesh(workScene)

 
 

+        self._doSceneClipping(workScene)

 
 

-        # Convert geometric object types to mesh Objects
-        geometricObjTypes = ['Mesh', 'Surf', 'Curve'] # TODO: add the Text type
-        Objects = workScene.getChildren()
-        objList = [ o for o in Objects if o.getType() in geometricObjTypes ]
-        for obj in objList:
-            old_obj = obj
-            obj = self._convertToRawMeshObj(obj)
-            workScene.link(obj)
-            workScene.unlink(old_obj)

 
 

+        # XXX: Joining objects does not work in batch mode!!
+        # Do not touch the following if, please :)
+
+        global OPTIMIZE_FOR_SPACE
+        if Blender.mode == 'background':
+            print "\nWARNING! Joining objects not supported in background mode!\n"
+            OPTIMIZE_FOR_SPACE = False

 
 

-        # FIXME: does not work!!, Blender segfaults on joins

         if OPTIMIZE_FOR_SPACE:
             self._joinMeshObjectsInScene(workScene)
 
         if OPTIMIZE_FOR_SPACE:
             self._joinMeshObjectsInScene(workScene)
 

-        
-        # global processing of the scene
-        self._doClipping()

 
         self._doSceneDepthSorting(workScene)
         
         # Per object activities
 
         self._doSceneDepthSorting(workScene)
         
         # Per object activities

-        Objects = workScene.getChildren()

 
 

+        Objects = workScene.getChildren()

         for obj in Objects:
             
         for obj in Objects:
             

-            if obj.getType() not in geometricObjTypes:
-                print "Only geometric Objects supported! - Skipping type:", obj.getType()
+            if obj.getType() != 'Mesh':
+                print "Only Mesh supported! - Skipping type:", obj.getType()

                 continue
 
             print "Rendering: ", obj.getName()
 
                 continue
 
             print "Rendering: ", obj.getName()
 

-            mesh = obj.data
+            mesh = obj.getData()

 
             self._doModelToWorldCoordinates(mesh, obj.matrix)
 
             self._doObjectDepthSorting(mesh)
             
 
             self._doModelToWorldCoordinates(mesh, obj.matrix)
 
             self._doObjectDepthSorting(mesh)
             

+            # We use both Mesh and NMesh because for depth sorting we change
+            # face order and Mesh class don't let us to do that.
+            mesh.update()
+            mesh = obj.getData(mesh=1)
+            

             self._doBackFaceCulling(mesh)
             
             self._doColorAndLighting(mesh)
 
             self._doBackFaceCulling(mesh)
             
             self._doColorAndLighting(mesh)
 

-            # TODO: 'style' can be a function that determine
-            # if an edge should be showed?
-            self._doEdgesStyle(mesh, style=None)
+            self._doEdgesStyle(mesh, edgeSelectionStyles[EDGE_STYLE])

 
 

-            self._doProjection(mesh, proj)
+            self._doProjection(mesh, self.proj)

             
             # Update the object data, important! :)
             mesh.update()
             
             # Update the object data, important! :)
             mesh.update()


@@ -684,19 +821,15 @@ class Renderer:
 
     # Utility methods
 
 
     # Utility methods
 

-    def _worldPosition(self, obj):
+    def _getObjPosition(self, obj):

         """Return the obj position in World coordinates.
         """
         return obj.matrix.translationPart()
 
         """Return the obj position in World coordinates.
         """
         return obj.matrix.translationPart()
 

-    def _cameraWorldPosition(self):
-        """Return the camera position in World coordinates.
-
-        This trick is needed when the camera follows a path and then
-        camera.loc does not correspond to the current real position of the
-        camera in the world.
+    def _cameraViewDirection(self):
+        """Get the View Direction form the camera matrix.

         """
         """

-        return self._worldPosition(self.cameraObj)
+        return Vector(self.cameraObj.matrix[2]).resize3D()

 
 
     # Faces methods
 
 
     # Faces methods


@@ -722,25 +855,20 @@ class Renderer:
         """
 
         normal = Vector(face.no)
         """
 
         normal = Vector(face.no)

-        c = self._cameraWorldPosition()
-
-        # View vector in orthographics projections can be considered simply as the
-        # camera position
-        view_vect = Vector(c)
-        #if self.cameraObj.data.getType() == 1:
-        #    view_vect = Vector(c)
-
-        # View vector as in perspective projections
-        # it is the difference between the camera position and one point of
-        # the face, we choose the farthest point.
-        # TODO: make the code more pythonic :)
+        camPos = self._getObjPosition(self.cameraObj)
+        view_vect = None
+
+        # View Vector in orthographics projections is the view Direction of
+        # the camera
+        if self.cameraObj.data.getType() == 1:
+            view_vect = self._cameraViewDirection()
+
+        # View vector in perspective projections can be considered as
+        # the difference between the camera position and one point of
+        # the face, we choose the farthest point from the camera.

         if self.cameraObj.data.getType() == 0:
         if self.cameraObj.data.getType() == 0:

-            max_len = 0
-            for vect in face:
-                vv = Vector(c) - Vector(vect.co)
-                if vv.length > max_len:
-                    max_len = vv.length
-                    view_vect = vv
+            vv = max( [ ((camPos - Vector(v.co)).length, (camPos - Vector(v.co))) for v in face] )
+            view_vect = vv[1]

 
         # if d > 0 the face is visible from the camera
         d = view_vect * normal
 
         # if d > 0 the face is visible from the camera
         d = view_vect * normal


@@ -753,11 +881,61 @@ class Renderer:
 
     # Scene methods
 
 
     # Scene methods
 

-    def _doClipping(self):
-        """Clip object against the View Frustum.
+    def _doConvertGeometricObjToMesh(self, scene):
+        """Convert all "geometric" objects to mesh ones.

         """
         """

-        print "TODO: _doClipping()"
-        return
+        geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text']
+
+        Objects = scene.getChildren()
+        objList = [ o for o in Objects if o.getType() in geometricObjTypes ]
+        for obj in objList:
+            old_obj = obj
+            obj = self._convertToRawMeshObj(obj)
+            scene.link(obj)
+            scene.unlink(old_obj)
+
+
+            # XXX Workaround for Text and Curve which have some normals
+            # inverted when they are converted to Mesh, REMOVE that when
+            # blender will fix that!!
+            if old_obj.getType() in ['Curve', 'Text']:
+                me = obj.getData(mesh=1)
+                for f in me.faces: f.sel = 1;
+                for v in me.verts: v.sel = 1;
+                me.remDoubles(0)
+                me.triangleToQuad()
+                me.recalcNormals()
+                me.update()
+
+
+    def _doSceneClipping(self, scene):
+        """Clip objects against the View Frustum.
+
+        For now clip away only objects according to their center position.
+        """
+
+        cpos = self._getObjPosition(self.cameraObj)
+        view_vect = self._cameraViewDirection()
+
+        near = self.cameraObj.data.clipStart
+        far  = self.cameraObj.data.clipEnd
+
+        aspect = float(self.canvasRatio[0])/float(self.canvasRatio[1])
+        fovy = atan(0.5/aspect/(self.cameraObj.data.lens/32))
+        fovy = fovy * 360.0/pi
+
+        Objects = scene.getChildren()
+        for o in Objects:
+            if o.getType() != 'Mesh': continue;
+
+            obj_vect = Vector(cpos) - self._getObjPosition(o)
+
+            d = obj_vect*view_vect
+            theta = AngleBetweenVecs(obj_vect, view_vect)
+            
+            # if the object is outside the view frustum, clip it away
+            if (d < near) or (d > far) or (theta > fovy):
+                scene.unlink(o)

 
     def _doSceneDepthSorting(self, scene):
         """Sort objects in the scene.
 
     def _doSceneDepthSorting(self, scene):
         """Sort objects in the scene.


@@ -765,40 +943,47 @@ class Renderer:
         The object sorting is done accordingly to the object centers.
         """
 
         The object sorting is done accordingly to the object centers.
         """
 

-        c = self._cameraWorldPosition()
+        c = self._getObjPosition(self.cameraObj)

 
 

-        Objects = scene.getChildren()
+        by_center_pos = (lambda o1, o2:
+                (o1.getType() == 'Mesh' and o2.getType() == 'Mesh') and
+                cmp((self._getObjPosition(o1) - Vector(c)).length,
+                    (self._getObjPosition(o2) - Vector(c)).length)
+            )

 
 

-        #Objects.sort(lambda obj1, obj2: 
-        #        cmp((Vector(obj1.loc) - Vector(c)).length,
-        #            (Vector(obj2.loc) - Vector(c)).length
-        #            )
-        #        )
+        # TODO: implement sorting by bounding box, if obj1.bb is inside obj2.bb,
+        # then ob1 goes farther than obj2, useful when obj2 has holes
+        by_bbox = None

         
         

-        Objects.sort(lambda obj1, obj2: 
-                cmp((self._worldPosition(obj1) - Vector(c)).length,
-                    (self._worldPosition(obj2) - Vector(c)).length
-                    )
-                )
+        Objects = scene.getChildren()
+        Objects.sort(by_center_pos)

         
         # update the scene
         for o in Objects:
             scene.unlink(o)
             scene.link(o)
         
         # update the scene
         for o in Objects:
             scene.unlink(o)
             scene.link(o)

-    

 
     def _joinMeshObjectsInScene(self, scene):
         """Merge all the Mesh Objects in a scene into a single Mesh Object.
         """
 
     def _joinMeshObjectsInScene(self, scene):
         """Merge all the Mesh Objects in a scene into a single Mesh Object.
         """

-        bigObj = Object.New('Mesh', 'BigOne')
+

         oList = [o for o in scene.getChildren() if o.getType()=='Mesh']
         oList = [o for o in scene.getChildren() if o.getType()=='Mesh']

-        print "Before join", oList
+
+        # FIXME: Object.join() do not work if the list contains 1 object
+        if len(oList) == 1:
+            return
+
+        mesh = Mesh.New()
+        bigObj = Object.New('Mesh', 'BigOne')
+        bigObj.link(mesh)
+

         bigObj.join(oList)
         bigObj.join(oList)

-        print "After join"

         scene.link(bigObj)
         for o in oList:
             scene.unlink(o)
 
         scene.link(bigObj)
         for o in oList:
             scene.unlink(o)
 

+        scene.update()
+

  
     # Per object methods
 
  
     # Per object methods
 


@@ -811,6 +996,11 @@ class Renderer:
         newObject = Object.New('Mesh', 'RawMesh_'+object.name)
         newObject.link(me)
 
         newObject = Object.New('Mesh', 'RawMesh_'+object.name)
         newObject.link(me)
 

+        # If the object has no materials set a default material
+        if not me.materials:
+            me.materials = [Material.New()]
+            #for f in me.faces: f.mat = 0
+

         newObject.setMatrix(object.getMatrix())
 
         return newObject
         newObject.setMatrix(object.getMatrix())
 
         return newObject


@@ -821,6 +1011,11 @@ class Renderer:
         This step is done simply applying to the object its tranformation
         matrix and recalculating its normals.
         """
         This step is done simply applying to the object its tranformation
         matrix and recalculating its normals.
         """

+        # XXX FIXME: blender do not transform normals in the right way when
+        # there are negative scale values
+        if matrix[0][0] < 0 or matrix[1][1] < 0 or matrix[2][2] < 0:
+            print "WARNING: Negative scales, expect incorrect results!"
+

         mesh.transform(matrix, True)
 
     def _doObjectDepthSorting(self, mesh):
         mesh.transform(matrix, True)
 
     def _doObjectDepthSorting(self, mesh):


@@ -829,23 +1024,26 @@ class Renderer:
         The faces in the object are sorted following the distance of the
         vertices from the camera position.
         """
         The faces in the object are sorted following the distance of the
         vertices from the camera position.
         """

-        c = self._cameraWorldPosition()
+        c = self._getObjPosition(self.cameraObj)

 
         # hackish sorting of faces
 
         # hackish sorting of faces

-        mesh.faces.sort(
-            lambda f1, f2:
-                # Sort faces according to the min distance from the camera
-                #cmp(min([(Vector(v.co)-Vector(c)).length for v in f1]),
-                #    min([(Vector(v.co)-Vector(c)).length for v in f2])))

 
 

-                # Sort faces according to the max distance from the camera
+        # Sort faces according to the max distance from the camera
+        by_max_vert_dist = (lambda f1, f2:

                 cmp(max([(Vector(v.co)-Vector(c)).length for v in f1]),
                     max([(Vector(v.co)-Vector(c)).length for v in f2])))
                 cmp(max([(Vector(v.co)-Vector(c)).length for v in f1]),
                     max([(Vector(v.co)-Vector(c)).length for v in f2])))

-                
-                # Sort faces according to the avg distance from the camera
-                #cmp(sum([(Vector(v.co)-Vector(c)).length for v in f1])/len(f1),
-                #    sum([(Vector(v.co)-Vector(c)).length for v in f2])/len(f2)))
+        
+        # Sort faces according to the min distance from the camera
+        by_min_vert_dist = (lambda f1, f2:
+                cmp(min([(Vector(v.co)-Vector(c)).length for v in f1]),
+                    min([(Vector(v.co)-Vector(c)).length for v in f2])))
+        
+        # Sort faces according to the avg distance from the camera
+        by_avg_vert_dist = (lambda f1, f2:
+                cmp(sum([(Vector(v.co)-Vector(c)).length for v in f1])/len(f1),
+                    sum([(Vector(v.co)-Vector(c)).length for v in f2])/len(f2)))

 
 

+        mesh.faces.sort(by_max_vert_dist)

         mesh.faces.reverse()
 
     def _doBackFaceCulling(self, mesh):
         mesh.faces.reverse()
 
     def _doBackFaceCulling(self, mesh):


@@ -855,7 +1053,8 @@ class Renderer:
         select the vertices belonging to visible faces.
         """
         
         select the vertices belonging to visible faces.
         """
         

-        # Select all vertices, so edges without faces can be displayed
+        # Select all vertices, so edges can be displayed even if there are no
+        # faces

         for v in mesh.verts:
             v.sel = 1
         
         for v in mesh.verts:
             v.sel = 1
         


@@ -868,17 +1067,15 @@ class Renderer:
 
         # Is this the correct way to propagate the face selection info to the
         # vertices belonging to a face ??
 
         # Is this the correct way to propagate the face selection info to the
         # vertices belonging to a face ??

-        # TODO: Using the Mesh class this should come for free. Right?
-        Mesh.Mode(Mesh.SelectModes['VERTEX'])
-        for f in mesh.faces:
-            if not f.sel:
-                for v in f:
-                    v.sel = 0
+        # TODO: Using the Mesh module this should come for free. Right?
+        #Mesh.Mode(Mesh.SelectModes['VERTEX'])
+        #for f in mesh.faces:
+        #    if not f.sel:
+        #        for v in f: v.sel = 0;

 
 

-        for f in mesh.faces:
-            if f.sel:
-                for v in f:
-                    v.sel = 1
+        #for f in mesh.faces:
+        #    if f.sel:
+        #        for v in f: v.sel = 1;

 
     def _doColorAndLighting(self, mesh):
         """Apply an Illumination model to the object.
 
     def _doColorAndLighting(self, mesh):
         """Apply an Illumination model to the object.


@@ -890,18 +1087,18 @@ class Renderer:
 
         # If the mesh has vertex colors already, use them,
         # otherwise turn them on and do some calculations
 
         # If the mesh has vertex colors already, use them,
         # otherwise turn them on and do some calculations

-        if mesh.hasVertexColours():
+        if mesh.vertexColors:

             return
             return

-        mesh.hasVertexColours(True)
+        mesh.vertexColors = 1

 
         materials = mesh.materials
         
         # TODO: use multiple lighting sources
         light_obj = self.lights[0]
 
         materials = mesh.materials
         
         # TODO: use multiple lighting sources
         light_obj = self.lights[0]

-        light_pos = self._worldPosition(light_obj)
+        light_pos = self._getObjPosition(light_obj)

         light = light_obj.data
 
         light = light_obj.data
 

-        camPos = self._cameraWorldPosition()
+        camPos = self._getObjPosition(self.cameraObj)

         
         # We do per-face color calculation (FLAT Shading), we can easily turn
         # to a per-vertex calculation if we want to implement some shading
         
         # We do per-face color calculation (FLAT Shading), we can easily turn
         # to a per-vertex calculation if we want to implement some shading


@@ -916,7 +1113,7 @@ class Renderer:
                 mat = materials[f.mat]
 
             # A new default material
                 mat = materials[f.mat]
 
             # A new default material

-            if not mat:
+            if mat == None:

                 mat = Material.New('defMat')
             
             L = Vector(light_pos).normalize()
                 mat = Material.New('defMat')
             
             L = Vector(light_pos).normalize()


@@ -940,38 +1137,60 @@ class Renderer:
             # Diffuse component (add light.col for kd)
             kd = mat.getRef() * Vector(mat.getRGBCol())
             Ip = light.getEnergy()
             # Diffuse component (add light.col for kd)
             kd = mat.getRef() * Vector(mat.getRGBCol())
             Ip = light.getEnergy()

-            Idiff = Ip * kd * (N*L)
-            
+            #Idiff = Ip * kd * int(N*L > 0.5)
+            Idiff = Ip * kd * MeshUtils.toonShading(N*L)
+

             # Specular component
             ks = mat.getSpec() * Vector(mat.getSpecCol())
             ns = mat.getHardness()
             # Specular component
             ks = mat.getSpec() * Vector(mat.getSpecCol())
             ns = mat.getHardness()

-            Ispec = Ip * ks * pow((V * R), ns)
+            Ispec = Ip * ks * pow((V*R), ns)

 
             # Emissive component
             ki = Vector([mat.getEmit()]*3)
 
             I = ki + Iamb + Idiff + Ispec
 
 
             # Emissive component
             ki = Vector([mat.getEmit()]*3)
 
             I = ki + Iamb + Idiff + Ispec
 

+
+            # Set Alpha component
+            I = list(I)
+            I.append(mat.getAlpha())
+
+            # Toon shading
+            #I = [MeshUtils.toonShading(c) for c in I] 
+

             # Clamp I values between 0 and 1
             I = [ min(c, 1) for c in I]
             I = [ max(0, c) for c in I]
             tmp_col = [ int(c * 255.0) for c in I]
 
             # Clamp I values between 0 and 1
             I = [ min(c, 1) for c in I]
             I = [ max(0, c) for c in I]
             tmp_col = [ int(c * 255.0) for c in I]
 

-            vcol = NMesh.Col(tmp_col[0], tmp_col[1], tmp_col[2], 255)
-            f.col = []
-            for v in f.v:
-                f.col.append(vcol)
+            for c in f.col:
+                c.r = tmp_col[0]
+                c.g = tmp_col[1]
+                c.b = tmp_col[2]
+                c.a = tmp_col[3]
+
+    def _doEdgesStyle(self, mesh, edgestyleSelect):
+        """Process Mesh Edges accroding to a given selection style.

 
 

-    def _doEdgesStyle(self, mesh, style):
-        """Process Mesh Edges. (For now copy the edge data, in next version it
-        can be a place where recognize silouhettes and/or contours).
+        Examples of algorithms:

 
 

-        input: an edge list
-        return: a processed edge list
+        Contours:
+            given an edge if its adjacent faces have the same normal (that is
+            they are complanar), than deselect it.
+
+        Silhouettes:
+            given an edge if one its adjacent faces is frontfacing and the
+            other is backfacing, than select it, else deselect.

         """
         """

-        #print "\tTODO: _doEdgeStyle()"
-        return

 
 

+        Mesh.Mode(Mesh.SelectModes['EDGE'])
+
+        for e in mesh.edges:
+
+            e.sel = 0
+            if edgestyleSelect(e, mesh):
+                e.sel = 1
+                

     def _doProjection(self, mesh, projector):
         """Calculate the Projection for the object.
         """
     def _doProjection(self, mesh, projector):
         """Calculate the Projection for the object.
         """


@@ -987,44 +1206,233 @@ class Renderer:
 
 # ---------------------------------------------------------------------
 #
 
 # ---------------------------------------------------------------------
 #

-## Main Program
+## GUI Class and Main Program

 #
 # ---------------------------------------------------------------------
 
 #
 # ---------------------------------------------------------------------
 

+
+from Blender import BGL, Draw
+from Blender.BGL import *
+
+class GUI:
+    
+    def _init():
+
+        # Output Format menu 
+        output_format = config.output['FORMAT']
+        default_value = outputWriters.keys().index(output_format)+1
+        GUI.outFormatMenu = Draw.Create(default_value)
+        GUI.evtOutFormatMenu = 0
+
+        # Animation toggle button
+        GUI.animToggle = Draw.Create(config.output['ANIMATION'])
+        GUI.evtAnimToggle = 1
+
+        # Join Objects toggle button
+        GUI.joinObjsToggle = Draw.Create(config.output['MERGED_OBJECTS'])
+        GUI.evtJoinObjsToggle = 2
+
+        # Render filled polygons
+        GUI.polygonsToggle = Draw.Create(config.polygons['FILL'])
+
+        GUI.evtPolygonsToggle = 3
+        # We hide the config.polygons['EXPANSION_TRICK'], for now
+
+        # Render polygon edges
+        GUI.showEdgesToggle = Draw.Create(config.edges['SHOW'])
+        GUI.evtShowEdgesToggle = 4
+
+        # Render hidden edges
+        GUI.showHiddenEdgesToggle = Draw.Create(config.edges['SHOW_HIDDEN'])
+        GUI.evtShowHiddenEdgesToggle = 5
+
+        # Edge Style menu 
+        edge_style = config.edges['STYLE']
+        default_value = edgeSelectionStyles.keys().index(edge_style)+1
+        GUI.edgeStyleMenu = Draw.Create(default_value)
+        GUI.evtEdgeStyleMenu = 6
+
+        # Edge Width slider
+        GUI.edgeWidthSlider = Draw.Create(config.edges['WIDTH'])
+        GUI.evtEdgeWidthSlider = 7
+
+        # Render Button
+        GUI.evtRenderButton = 8
+
+        # Exit Button
+        GUI.evtExitButton = 9
+
+    def draw():
+
+        # initialize static members
+        GUI._init()
+
+        glClear(GL_COLOR_BUFFER_BIT)
+        glColor3f(0.0, 0.0, 0.0)
+        glRasterPos2i(10, 350)
+        Draw.Text("VRM: Vector Rendering Method script.")
+        glRasterPos2i(10, 335)
+        Draw.Text("Press Q or ESC to quit.")
+
+        # Build the output format menu
+        glRasterPos2i(10, 310)
+        Draw.Text("Select the output Format:")
+        outMenuStruct = "Output Format %t"
+        for t in outputWriters.keys():
+           outMenuStruct = outMenuStruct + "|%s" % t
+        GUI.outFormatMenu = Draw.Menu(outMenuStruct, GUI.evtOutFormatMenu,
+                10, 285, 160, 18, GUI.outFormatMenu.val, "Choose the Output Format")
+
+        # Animation toggle
+        GUI.animToggle = Draw.Toggle("Animation", GUI.evtAnimToggle,
+                10, 260, 160, 18, GUI.animToggle.val,
+                "Toggle rendering of animations")
+
+        # Join Objects toggle
+        GUI.joinObjsToggle = Draw.Toggle("Join objects", GUI.evtJoinObjsToggle,
+                10, 235, 160, 18, GUI.joinObjsToggle.val,
+                "Join objects in the rendered file")
+
+        # Render Button
+        Draw.Button("Render", GUI.evtRenderButton, 10, 210-25, 75, 25+18,
+                "Start Rendering")
+        Draw.Button("Exit", GUI.evtExitButton, 95, 210-25, 75, 25+18, "Exit!")
+
+        # Rendering Styles
+        glRasterPos2i(200, 310)
+        Draw.Text("Rendering Style:")
+
+        # Render Polygons
+        GUI.polygonsToggle = Draw.Toggle("Filled Polygons", GUI.evtPolygonsToggle,
+                200, 285, 160, 18, GUI.polygonsToggle.val,
+                "Render filled polygons")
+
+        # Render Edges
+        GUI.showEdgesToggle = Draw.Toggle("Show Edges", GUI.evtShowEdgesToggle,
+                200, 260, 160, 18, GUI.showEdgesToggle.val,
+                "Render polygon edges")
+
+        if GUI.showEdgesToggle.val == 1:
+            
+            # Edge Style
+            edgeStyleMenuStruct = "Edge Style %t"
+            for t in edgeSelectionStyles.keys():
+               edgeStyleMenuStruct = edgeStyleMenuStruct + "|%s" % t
+            GUI.edgeStyleMenu = Draw.Menu(edgeStyleMenuStruct, GUI.evtEdgeStyleMenu,
+                    200, 235, 160, 18, GUI.edgeStyleMenu.val,
+                    "Choose the edge style")
+
+            # Edge size
+            GUI.edgeWidthSlider = Draw.Slider("Width: ", GUI.evtEdgeWidthSlider,
+                    200, 210, 160, 18, GUI.edgeWidthSlider.val,
+                    0.0, 10.0, 0, "Change Edge Width")
+
+            # Show Hidden Edges
+            GUI.showHiddenEdgesToggle = Draw.Toggle("Show Hidden Edges",
+                    GUI.evtShowHiddenEdgesToggle,
+                    200, 185, 160, 18, GUI.showHiddenEdgesToggle.val,
+                    "Render hidden edges as dashed lines")
+
+        glRasterPos2i(10, 160)
+        Draw.Text("Antonio Ospite (c) 2006")
+
+    def event(evt, val):
+
+        if evt == Draw.ESCKEY or evt == Draw.QKEY:
+            Draw.Exit()
+        else:
+            return
+
+        Draw.Redraw(1)
+
+    def button_event(evt):
+
+        if evt == GUI.evtExitButton:
+            Draw.Exit()
+
+        elif evt == GUI.evtOutFormatMenu:
+            i = GUI.outFormatMenu.val - 1
+            config.output['FORMAT']= outputWriters.keys()[i]
+
+        elif evt == GUI.evtAnimToggle:
+            config.outpur['ANIMATION'] = bool(GUI.animToggle.val)
+
+        elif evt == GUI.evtJoinObjsToggle:
+            config.output['MERGED_OBJECTS'] = bool(GUI.joinObjsToggle.val)
+
+        elif evt == GUI.evtPolygonsToggle:
+            config.polygons['FILL'] = bool(GUI.polygonsToggle.val)
+
+        elif evt == GUI.evtShowEdgesToggle:
+            config.edges['SHOW'] = bool(GUI.showEdgesToggle.val)
+
+        elif evt == GUI.evtShowHiddenEdgesToggle:
+            config.edges['SHOW_HIDDEN'] = bool(GUI.showHiddenEdgesToggle.val)
+
+        elif evt == GUI.evtEdgeStyleMenu:
+            i = GUI.edgeStyleMenu.val - 1
+            config.edges['STYLE'] = edgeSelectionStyles.keys()[i]
+
+        elif evt == GUI.evtEdgeWidthSlider:
+            config.edges['WIDTH'] = float(GUI.edgeWidthSlider.val)
+
+        elif evt == GUI.evtRenderButton:
+            label = "Save %s" % config.output['FORMAT']
+            # Show the File Selector
+            global outputfile
+            Blender.Window.FileSelector(vectorize, label, outputfile)
+
+        else:
+            print "Event: %d not handled!" % evt
+
+        if evt:
+            Draw.Redraw(1)
+            GUI.conf_debug()
+
+    def conf_debug():
+        from pprint import pprint
+        pprint(config)
+
+    _init = staticmethod(_init)
+    draw = staticmethod(draw)
+    event = staticmethod(event)
+    button_event = staticmethod(button_event)
+    conf_debug = staticmethod(conf_debug)
+
+# A wrapper function for the vectorizing process

 def vectorize(filename):
     """The vectorizing process is as follows:
      
      - Instanciate the writer and the renderer
      - Render!
      """
 def vectorize(filename):
     """The vectorizing process is as follows:
      
      - Instanciate the writer and the renderer
      - Render!
      """

+
+    if filename == "":
+        print "\nERROR: invalid file name!"
+        return
+

     from Blender import Window
     editmode = Window.EditMode()
     if editmode: Window.EditMode(0)
 
     from Blender import Window
     editmode = Window.EditMode()
     if editmode: Window.EditMode(0)
 

-    writer = SVGVectorWriter(filename)
+    actualWriter = outputWriters[config.output['FORMAT']]
+    writer = actualWriter(filename)

     
     renderer = Renderer()
     
     renderer = Renderer()

-    renderer.doRendering(writer, RENDER_ANIMATION)
+    renderer.doRendering(writer, config.output['ANIMATION'])

 
     if editmode: Window.EditMode(1) 
 
 
     if editmode: Window.EditMode(1) 
 

-def vectorize_gui(filename):
-    """Draw the gui.
-
-    I would like to keep that simple, really.
-    """
-    Blender.Window.FileSelector (vectorize, 'Save SVG', filename)
-    Blender.Redraw()
-

 
 # Here the main
 if __name__ == "__main__":
     
 
 # Here the main
 if __name__ == "__main__":
     

-    import os
-    outputfile = os.path.splitext(Blender.Get('filename'))[0]+".svg"
+    outputfile = ""
+    basename = Blender.sys.basename(Blender.Get('filename'))
+    if basename != "":
+        outputfile = Blender.sys.splitext(basename)[0] + "." + str(config.output['FORMAT']).lower()

 
 

-    # with this trick we can run the script in batch mode
-    try:
-        vectorize_gui(outputfile)
-    except:
+    if Blender.mode == 'background':

         vectorize(outputfile)
         vectorize(outputfile)

+    else:
+        Draw.Register(GUI.draw, GUI.event, GUI.button_event)