Edge styles (silhouettes, contours)

[vrm.git] / vrm.py

diff --git a/vrm.py b/vrm.py
index 69099c4..b3aac25 100755 (executable)
--- a/vrm.py
+++ b/vrm.py
@@ -2,12 +2,12 @@
 """
 Name: 'VRM'
 Blender: 241
 """
 Name: 'VRM'
 Blender: 241

-Group: 'Export'
-Tooltip: 'Vector Rendering Method Export Script'
+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,21 @@ __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?

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


@@ -75,17 +78,81 @@ from math import *
 
 # Some global settings
 PRINT_POLYGONS     = True
 
 # Some global settings
 PRINT_POLYGONS     = True

-PRINT_EDGES        = False
-SHOW_HIDDEN_EDGES  = False
+POLYGON_EXPANSION_TRICK = True

 
 

+PRINT_EDGES        = True
+SHOW_HIDDEN_EDGES  = False
+#EDGE_STYLE = 'normal'
+EDGE_STYLE = 'silhouette'

 EDGES_WIDTH = 0.5
 
 EDGES_WIDTH = 0.5
 

-POLYGON_EXPANSION_TRICK = True
-

 RENDER_ANIMATION = False
 
 RENDER_ANIMATION = False
 

-# Do not work for now!
-OPTIMIZE_FOR_SPACE = False
+OPTIMIZE_FOR_SPACE = True
+
+OUTPUT_FORMAT = 'SVG'
+
+
+# ---------------------------------------------------------------------
+#
+## Utility Mesh class
+#
+# ---------------------------------------------------------------------
+class MeshUtils:
+    def __init__(self):
+        return
+
+    def getEdgeAdjacentFaces(self, 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(self, 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 = self.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(self, 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 = self.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
+

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


@@ -129,7 +196,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 +280,10 @@ class Projector:
         return m
 
 
         return m
 
 

+

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

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

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


@@ -293,10 +360,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 +381,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):


@@ -443,7 +513,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 +529,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 +539,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])+");")
+            # 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 POLYGON_EXPANSION_TRICK:
             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")
+                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 +571,9 @@ 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:
+            # We consider an edge visible if _both_ its vertices are selected,
+            # hence an edge is hidden if _any_ of its vertices is deselected.
+            if e.sel == 0:

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


@@ -568,7 +649,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.
         """


@@ -623,52 +704,54 @@ class Renderer:
         # projection transformations
         proj = Projector(self.cameraObj, self.canvasRatio)
 
         # projection transformations
         proj = Projector(self.cameraObj, self.canvasRatio)
 

+        # global processing of the scene
+
+        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, proj)
             


@@ -684,19 +767,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 +801,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 +827,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 +889,41 @@ 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.
         """

+        mesh = Mesh.New()

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

+        bigObj.link(mesh)
+

         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

         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 +936,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


@@ -829,23 +959,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 +988,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 +1002,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 +1022,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 +1048,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()


@@ -952,26 +1084,44 @@ class Renderer:
 
             I = ki + Iamb + Idiff + Ispec
 
 
             I = ki + Iamb + Idiff + Ispec
 

+            # Set Alpha component
+            I = list(I)
+            I.append(mat.getAlpha())
+

             # 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, style):
-        """Process Mesh Edges. (For now copy the edge data, in next version it
-        can be a place where recognize silouhettes and/or contours).
+    def _doEdgesStyle(self, mesh, edgestyleSelect):
+        """Process Mesh Edges accroding to a given selection style.

 
 

-        input: an edge list
-        return: a processed edge list
+        Examples of algorithms:
+
+        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:
+
+            if edgestyleSelect(e, mesh):
+                e.sel = 1
+            else:
+                e.sel = 0
+                

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


@@ -991,6 +1141,20 @@ class Renderer:
 #
 # ---------------------------------------------------------------------
 
 #
 # ---------------------------------------------------------------------
 

+# 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,
+        }
+
+
+# A wrapper function for the vectorizing process

 def vectorize(filename):
     """The vectorizing process is as follows:
      
 def vectorize(filename):
     """The vectorizing process is as follows:
      


@@ -1001,30 +1165,23 @@ def vectorize(filename):
     editmode = Window.EditMode()
     if editmode: Window.EditMode(0)
 
     editmode = Window.EditMode()
     if editmode: Window.EditMode(0)
 

-    writer = SVGVectorWriter(filename)
+    writer = outputWriters[OUTPUT_FORMAT](filename)

     
     renderer = Renderer()
     renderer.doRendering(writer, RENDER_ANIMATION)
 
     if editmode: Window.EditMode(1) 
 
     
     renderer = Renderer()
     renderer.doRendering(writer, RENDER_ANIMATION)
 
     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"
+    basename = Blender.sys.basename(Blender.Get('filename'))
+    outputfile = Blender.sys.splitext(basename)[0]+".svg"

 
 

-    # 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:
+        label = "Save %s" % OUTPUT_FORMAT
+        Blender.Window.FileSelector(vectorize, label, outputfile)
+        Blender.Redraw()