Fixes to Newell algorithm implementation

[vrm.git] / vrm.py

diff --git a/vrm.py b/vrm.py
index 312d8af..82922f8 100755 (executable)
--- a/vrm.py
+++ b/vrm.py
@@ -1,14 +1,14 @@
 #!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"]
-__version__ = "0.3"
+__url__ = ["http://projects.blender.org/projects/vrm"]
+__version__ = "0.3.beta"

 
 __bpydoc__ = """\
     Render the scene and save the result in vector format.
 
 __bpydoc__ = """\
     Render the scene and save the result in vector format.


@@ -42,51 +42,212 @@ __bpydoc__ = """\
 # ---------------------------------------------------------------------
 # 
 # Things TODO for a next release:
 # ---------------------------------------------------------------------
 # 
 # Things TODO for a next release:

-#   - Switch to the Mesh structure, should be considerably faster
-#    (partially done, but cannot sort faces, yet)
+#   - FIX the issue with negative scales in object tranformations!

 #   - Use a better depth sorting algorithm
 #   - Use a better depth sorting algorithm

+#   - Implement clipping of primitives and do handle object intersections.
+#     (for now only clipping away whole objects is supported).

 #   - Review how selections are made (this script uses selection states of
 #     primitives to represent visibility infos)
 #   - Review how selections are made (this script uses selection states of
 #     primitives to represent visibility infos)

-#   - Implement clipping of primitives and do handle object intersections.
-#     (for now only clipping for whole objects is supported).
-#   - Implement Edge Styles (silhouettes, contours, etc.)
-#   - Implement Edge coloring
-#   - Use multiple lighting sources in color calculation
-#   - Implement Shading Styles?
-#   - Use another representation for the 2D projection? 
-#     Think to a way to merge adjacent polygons that have the same color.
-#   - Add other Vector Writers.
+#   - 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.
+#     Or a way to use paths for silhouettes and contours.
+#   - Consider SMIL for animation handling instead of ECMA Script? (Firefox do
+#     not support SMIL for animations)
+#   - Switch to the Mesh structure, should be considerably faster
+#     (partially done, but with Mesh we cannot sort faces, yet)
+#   - Implement Edge Styles (silhouettes, contours, etc.) (partially done).
+#   - Implement Shading Styles? (partially done, to make more flexible).
+#   - Add Vector Writers other than SVG.
+#   - Check memory use!!
+#   - Support Indexed palettes!! (Useful for ILDA FILES, for example,
+#     see http://www.linux-laser.org/download/autotrace/ilda-output.patch)

 #
 # ---------------------------------------------------------------------
 #
 # Changelog:
 #
 #
 # ---------------------------------------------------------------------
 #
 # Changelog:
 #

-#   vrm-0.3.py  -   2006-05-19
-#    * First release after code restucturing.
-#      Now the script offers a useful set of functionalities
-#      and it can render animations, too.
+#   vrm-0.3.py  - ...
+#     * First release after code restucturing.
+#       Now the script offers a useful set of functionalities
+#       and it can render animations, too.
+#     * Optimization in Renderer.doEdgeStyle(), build a topology cache
+#       so to speed up the lookup of adjacent faces of an edge.
+#       Thanks ideasman42.
+#     * The SVG output is now SVG 1.0 valid.
+#       Checked with: http://jiggles.w3.org/svgvalidator/ValidatorURI.html
+#     * Progress indicator during HSR.

 #
 # ---------------------------------------------------------------------
 
 import Blender
 #
 # ---------------------------------------------------------------------
 
 import Blender

-from Blender import Scene, Object, Mesh, NMesh, Material, Lamp, Camera
+from Blender import Scene, Object, Mesh, NMesh, Material, Lamp, Camera, Window

 from Blender.Mathutils import *
 from math import *
 from Blender.Mathutils import *
 from math import *

+import sys, time

 
 
 # 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['SHOW'] = True
+    polygons['SHADING'] = 'FLAT'
+    #polygons['HSR'] = 'PAINTER' # 'PAINTER' or 'NEWELL'
+    polygons['HSR'] = 'NEWELL'
+    # Hidden to the user for now
+    polygons['EXPANSION_TRICK'] = True
+
+    polygons['TOON_LEVELS'] = 2
+
+    edges = dict()
+    edges['SHOW'] = False
+    edges['SHOW_HIDDEN'] = False
+    edges['STYLE'] = 'MESH'
+    edges['WIDTH'] = 2
+    edges['COLOR'] = [0, 0, 0]
+
+    output = dict()
+    output['FORMAT'] = 'SVG'
+    output['ANIMATION'] = False
+    output['JOIN_OBJECTS'] = True
+
+
+
+# Utility functions
+print_debug = True
+def debug(msg):
+    if print_debug:
+        sys.stderr.write(msg)
+
+def sign(x):
+    if x == 0:
+        return 0
+    elif x < 0:
+        return -1
+    else:
+        return 1
+
+
+# ---------------------------------------------------------------------
+#
+## Mesh Utility class
+#
+# ---------------------------------------------------------------------
+class MeshUtils:
+
+    def buildEdgeFaceUsersCache(me):
+        ''' 
+        Takes a mesh and returns a list aligned with the meshes edges.
+        Each item is a list of the faces that use the edge
+        would be the equiv for having ed.face_users as a property
+
+        Taken from .blender/scripts/bpymodules/BPyMesh.py,
+        thanks to ideasman_42.
+        '''
+
+        def sorted_edge_indicies(ed):
+            i1= ed.v1.index
+            i2= ed.v2.index
+            if i1>i2:
+                i1,i2= i2,i1
+            return i1, i2
+
+       
+        face_edges_dict= dict([(sorted_edge_indicies(ed), (ed.index, [])) for ed in me.edges])
+        for f in me.faces:
+            fvi= [v.index for v in f.v]# face vert idx's
+            for i in xrange(len(f)):
+                i1= fvi[i]
+                i2= fvi[i-1]
+                
+                if i1>i2:
+                    i1,i2= i2,i1
+                
+                face_edges_dict[i1,i2][1].append(f)
+        
+        face_edges= [None] * len(me.edges)
+        for ed_index, ed_faces in face_edges_dict.itervalues():
+            face_edges[ed_index]= ed_faces
+        
+        return face_edges
+
+    def isMeshEdge(adjacent_faces):
+        """Mesh edge rule.
+
+        A mesh edge is visible if _at_least_one_ 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.
+        """
+
+        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(adjacent_faces):
+        """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.
+        """
+
+        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
+
+    buildEdgeFaceUsersCache = staticmethod(buildEdgeFaceUsersCache)
+    isMeshEdge = staticmethod(isMeshEdge)
+    isSilhouetteEdge = staticmethod(isSilhouetteEdge)
+
+
+# ---------------------------------------------------------------------
+#
+## Shading Utility class
+#
+# ---------------------------------------------------------------------
+class ShadingUtils:
+
+    shademap = None
+
+    def toonShadingMapSetup():
+        levels = config.polygons['TOON_LEVELS']
+
+        texels = 2*levels - 1
+        tmp_shademap = [0.0] + [(i)/float(texels-1) for i in xrange(1, texels-1) ] + [1.0]

 
 

-POLYGON_EXPANSION_TRICK = True
+        return tmp_shademap

 
 

-RENDER_ANIMATION = False
+    def toonShading(u):

 
 

-# Does not work in batch mode!!
-#OPTIMIZE_FOR_SPACE = True
+        shademap = ShadingUtils.shademap
+
+        if not shademap:
+            shademap = ShadingUtils.toonShadingMapSetup()
+
+        v = 1.0
+        for i in xrange(0, len(shademap)-1):
+            pivot = (shademap[i]+shademap[i+1])/2.0
+            j = int(u>pivot)
+
+            v = shademap[i+j]
+
+            if v < shademap[i+1]:
+                return v
+
+        return v
+
+    toonShadingMapSetup = staticmethod(toonShadingMapSetup)
+    toonShading = staticmethod(toonShading)

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


@@ -124,11 +285,10 @@ class Projector:
         fovy = fovy * 360.0/pi
         
         # What projection do we want?
         fovy = fovy * 360.0/pi
         
         # What projection do we want?

-        if camera.type:
-            #mP = self._calcOrthoMatrix(fovy, aspect, near, far, 17) #camera.scale) 
-            mP = self._calcOrthoMatrix(fovy, aspect, near, far, scale) 
-        else:
+        if camera.type == 0:

             mP = self._calcPerspectiveMatrix(fovy, aspect, near, far) 
             mP = self._calcPerspectiveMatrix(fovy, aspect, near, far) 

+        elif camera.type == 1:
+            mP = self._calcOrthoMatrix(fovy, aspect, near, far, scale) 

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


@@ -150,11 +310,16 @@ class Projector:
         """
         
         # Note that we have to work on the vertex using homogeneous coordinates
         """
         
         # Note that we have to work on the vertex using homogeneous coordinates

+        # From blender 2.42+ we don't need to resize the vector to be 4d
+        # when applying a 4x4 matrix, but we do that anyway since we need the
+        # 4th coordinate later

         p = self.projectionMatrix * Vector(v).resize4D()
         p = self.projectionMatrix * Vector(v).resize4D()

-
-        if p[3]>0:
+        
+        # Perspective division
+        if p[3] != 0:

             p[0] = p[0]/p[3]
             p[1] = p[1]/p[3]
             p[0] = p[0]/p[3]
             p[1] = p[1]/p[3]

+            p[2] = p[2]/p[3]

 
         # restore the size
         p[3] = 1.0
 
         # restore the size
         p[3] = 1.0


@@ -162,6 +327,7 @@ class Projector:
 
         return p
 
 
         return p
 

+

     ##
     # Private methods
     #
     ##
     # Private methods
     #


@@ -216,7 +382,173 @@ class Projector:
 
 # ---------------------------------------------------------------------
 #
 
 # ---------------------------------------------------------------------
 #

-## 2DObject representation class
+## Progress Indicator
+#
+# ---------------------------------------------------------------------
+
+class Progress:
+    """A model for a progress indicator.
+    
+    Do the progress calculation calculation and
+    the view independent stuff of a progress indicator.
+    """
+    def __init__(self, steps=0):
+        self.name = ""
+        self.steps = steps
+        self.completed = 0
+        self.progress = 0
+
+    def setSteps(self, steps):
+        """Set the number of steps of the activity wich we want to track.
+        """
+        self.steps = steps
+
+    def getSteps(self):
+        return self.steps
+
+    def setName(self, name):
+        """Set the name of the activity wich we want to track.
+        """
+        self.name = name
+
+    def getName(self):
+        return self.name
+
+    def getProgress(self):
+        return self.progress
+
+    def reset(self):
+        self.completed = 0
+        self.progress = 0
+
+    def update(self):
+        """Update the model, call this method when one step is completed.
+        """
+        if self.progress == 100:
+            return False
+
+        self.completed += 1
+        self.progress = ( float(self.completed) / float(self.steps) ) * 100
+        self.progress = int(self.progress)
+
+        return True
+
+
+class ProgressIndicator:
+    """An abstraction of a View for the Progress Model
+    """
+    def __init__(self):
+
+        # Use a refresh rate so we do not show the progress at
+        # every update, but every 'self.refresh_rate' times.
+        self.refresh_rate = 10
+        self.shows_counter = 0
+
+        self.quiet = False
+
+        self.progressModel = None
+
+    def setQuiet(self, value):
+        self.quiet = value
+
+    def setActivity(self, name, steps):
+        """Initialize the Model.
+
+        In a future version (with subactivities-progress support) this method
+        could only set the current activity.
+        """
+        self.progressModel = Progress()
+        self.progressModel.setName(name)
+        self.progressModel.setSteps(steps)
+
+    def getActivity(self):
+        return self.progressModel
+
+    def update(self):
+        """Update the model and show the actual progress.
+        """
+        assert(self.progressModel)
+
+        if self.progressModel.update():
+            if self.quiet:
+                return
+
+            self.show(self.progressModel.getProgress(),
+                    self.progressModel.getName())
+
+        # We return always True here so we can call the update() method also
+        # from lambda funcs (putting the call in logical AND with other ops)
+        return True
+
+    def show(self, progress, name=""):
+        self.shows_counter = (self.shows_counter + 1) % self.refresh_rate
+        if self.shows_counter != 0:
+            return
+
+        if progress == 100:
+            self.shows_counter = -1
+
+
+class ConsoleProgressIndicator(ProgressIndicator):
+    """Show a progress bar on stderr, a la wget.
+    """
+    def __init__(self):
+        ProgressIndicator.__init__(self)
+
+        self.swirl_chars = ["-", "\\", "|", "/"]
+        self.swirl_count = -1
+
+    def show(self, progress, name):
+        ProgressIndicator.show(self, progress, name)
+        
+        bar_length = 70
+        bar_progress = int( (progress/100.0) * bar_length )
+        bar = ("=" * bar_progress).ljust(bar_length)
+
+        self.swirl_count = (self.swirl_count+1)%len(self.swirl_chars)
+        swirl_char = self.swirl_chars[self.swirl_count]
+
+        progress_bar = "%s |%s| %c %3d%%" % (name, bar, swirl_char, progress)
+
+        sys.stderr.write(progress_bar+"\r")
+        if progress == 100:
+            sys.stderr.write("\n")
+
+
+class GraphicalProgressIndicator(ProgressIndicator):
+    """Interface to the Blender.Window.DrawProgressBar() method.
+    """
+    def __init__(self):
+        ProgressIndicator.__init__(self)
+
+        #self.swirl_chars = ["-", "\\", "|", "/"]
+        # We have to use letters with the same width, for now!
+        # Blender progress bar considers the font widths when
+        # calculating the progress bar width.
+        self.swirl_chars = ["\\", "/"]
+        self.swirl_count = -1
+
+    def show(self, progress, name):
+        ProgressIndicator.show(self, progress)
+
+        self.swirl_count = (self.swirl_count+1)%len(self.swirl_chars)
+        swirl_char = self.swirl_chars[self.swirl_count]
+
+        progress_text = "%s - %c %3d%%" % (name, swirl_char, progress)
+
+        # Finally draw  the Progress Bar
+        Window.WaitCursor(1) # Maybe we can move that call in the constructor?
+        Window.DrawProgressBar(progress/100.0, progress_text)
+
+        if progress == 100:
+            Window.DrawProgressBar(1, progress_text)
+            Window.WaitCursor(0)
+
+
+
+# ---------------------------------------------------------------------
+#
+## 2D Object representation class

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


@@ -337,6 +669,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'):


@@ -386,16 +719,16 @@ class SVGVectorWriter(VectorWriter):
         """Print SVG header."""
 
         self.file.write("<?xml version=\"1.0\"?>\n")
         """Print SVG header."""
 
         self.file.write("<?xml version=\"1.0\"?>\n")

-        self.file.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n")
-        self.file.write("\t\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n")
-        self.file.write("<svg version=\"1.1\"\n")
+        self.file.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.0//EN\"\n")
+        self.file.write("\t\"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\">\n")
+        self.file.write("<svg version=\"1.0\"\n")

         self.file.write("\txmlns=\"http://www.w3.org/2000/svg\"\n")
         self.file.write("\txmlns=\"http://www.w3.org/2000/svg\"\n")

-        self.file.write("\twidth=\"%d\" height=\"%d\" streamable=\"true\">\n\n" %
+        self.file.write("\twidth=\"%d\" height=\"%d\">\n\n" %

                 self.canvasSize)
 
         if self.animation:
 
                 self.canvasSize)
 
         if self.animation:
 

-            self.file.write("""\n<script><![CDATA[
+            self.file.write("""\n<script type="text/javascript"><![CDATA[

             globalStartFrame=%d;
             globalEndFrame=%d;
 
             globalStartFrame=%d;
             globalEndFrame=%d;
 


@@ -435,7 +768,7 @@ class SVGVectorWriter(VectorWriter):
 
         self.file.write("\n</svg>\n")
 
 
         self.file.write("\n</svg>\n")
 

-    def _printPolygons(self, mesh):
+    def _printPolygons(self, mesh): 

         """Print the selected (visible) polygons.
         """
 
         """Print the selected (visible) polygons.
         """
 


@@ -446,40 +779,51 @@ 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("<path d=\"")

 
 

-            self.file.write("<polygon points=\"")
+            p = self._calcCanvasCoord(face.verts[0])
+            self.file.write("M %g,%g L " % (p[0], p[1]))

 
 

-            for v in face:
+            for v in face.verts[1:]:

                 p = self._calcCanvasCoord(v)
                 self.file.write("%g,%g " % (p[0], p[1]))
             
             # get rid of the last blank space, just cosmetics here.
             self.file.seek(-1, 1) 
                 p = self._calcCanvasCoord(v)
                 self.file.write("%g,%g " % (p[0], p[1]))
             
             # get rid of the last blank space, just cosmetics here.
             self.file.seek(-1, 1) 

-            self.file.write("\"\n")
+            self.file.write(" z\"\n")

             
             # take as face color the first vertex color
             
             # take as face color the first vertex color

-            # TODO: the average of vetrex colors?

             if face.col:
                 fcol = face.col[0]
                 color = [fcol.r, fcol.g, fcol.b, fcol.a]
             else:
                 color = [255, 255, 255, 255]
 
             if face.col:
                 fcol = face.col[0]
                 color = [fcol.r, fcol.g, fcol.b, fcol.a]
             else:
                 color = [255, 255, 255, 255]
 

-            # use the stroke property to alleviate the "adjacent edges" problem,
-            # we simulate polygon expansion using borders,
-            # see http://www.antigrain.com/svg/index.html for more info
-            stroke_col = color
-            stroke_width = 0.5
-

             # Convert the color to the #RRGGBB form
             str_col = "#%02X%02X%02X" % (color[0], color[1], 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("\tstyle=\"fill:" + str_col + ";")

-            if POLYGON_EXPANSION_TRICK:
-                self.file.write(" stroke:" + str_col + ";")
+            self.file.write(opacity_string)
+
+            # use the stroke property to alleviate the "adjacent edges" problem,
+            # we simulate polygon expansion using borders,
+            # see http://www.antigrain.com/svg/index.html for more info
+            stroke_width = 1.0
+
+            if config.polygons['EXPANSION_TRICK']:
+                str_col = "#000000" # For debug
+                self.file.write(" stroke:%s;\n" % str_col)

                 self.file.write(" stroke-width:" + str(stroke_width) + ";\n")
                 self.file.write(" stroke-linecap:round;stroke-linejoin:round")
                 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("</g>\n")
             self.file.write("\"/>\n")
 
         self.file.write("</g>\n")


@@ -488,8 +832,8 @@ class SVGVectorWriter(VectorWriter):
         """Print the wireframe using mesh edges.
         """
 
         """Print the wireframe using mesh edges.
         """
 

-        stroke_width=EDGES_WIDTH
-        stroke_col = [0, 0, 0]
+        stroke_width = config.edges['WIDTH']
+        stroke_col = config.edges['COLOR']

         
         self.file.write("<g>\n")
 
         
         self.file.write("<g>\n")
 


@@ -497,8 +841,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:


@@ -518,15 +861,29 @@ class SVGVectorWriter(VectorWriter):
         self.file.write("</g>\n")
 
 
         self.file.write("</g>\n")
 
 

-

 # ---------------------------------------------------------------------
 #
 ## Rendering Classes
 #
 # ---------------------------------------------------------------------
 
 # ---------------------------------------------------------------------
 #
 ## Rendering Classes
 #
 # ---------------------------------------------------------------------
 

+# A dictionary to collect different shading style methods
+shadingStyles = dict()
+shadingStyles['FLAT'] = None
+shadingStyles['TOON'] = None
+
+# A dictionary to collect different edge style methods
+edgeStyles = dict()
+edgeStyles['MESH'] = MeshUtils.isMeshEdge
+edgeStyles['SILHOUETTE'] = MeshUtils.isSilhouetteEdge
+
+# A dictionary to collect the supported output formats
+outputWriters = dict()
+outputWriters['SVG'] = SVGVectorWriter
+
+

 class Renderer:
 class Renderer:

-    """Render a scene viewed from a given camera.
+    """Render a scene viewed from the active camera.

     
     This class is responsible of the rendering process, transformation and
     projection of the objects in the scene are invoked by the renderer.
     
     This class is responsible of the rendering process, transformation and
     projection of the objects in the scene are invoked by the renderer.


@@ -537,7 +894,7 @@ class Renderer:
     def __init__(self):
         """Make the rendering process only for the current scene by default.
 
     def __init__(self):
         """Make the rendering process only for the current scene by default.
 

-        We will work on a copy of the scene, be sure that the current scene do
+        We will work on a copy of the scene, to be sure that the current scene do

         not get modified in any way.
         """
 
         not get modified in any way.
         """
 


@@ -554,15 +911,23 @@ class Renderer:
 
         # Render from the currently active camera 
         self.cameraObj = self._SCENE.getCurrentCamera()
 
         # Render from the currently active camera 
         self.cameraObj = self._SCENE.getCurrentCamera()

-        print dir(self._SCENE)
+
+        # 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)
 


@@ -581,11 +946,11 @@ class Renderer:
         """
         
         context = self._SCENE.getRenderingContext()
         """
         
         context = self._SCENE.getRenderingContext()

-        currentFrame = context.currentFrame()
+        origCurrentFrame = context.currentFrame()

 
         # Handle the animation case
         if not animation:
 
         # Handle the animation case
         if not animation:

-            startFrame = currentFrame
+            startFrame = origCurrentFrame

             endFrame = startFrame
             outputWriter.open()
         else:
             endFrame = startFrame
             outputWriter.open()
         else:


@@ -594,80 +959,100 @@ class Renderer:
             outputWriter.open(startFrame, endFrame)
         
         # Do the rendering process frame by frame
             outputWriter.open(startFrame, endFrame)
         
         # Do the rendering process frame by frame

-        print "Start Rendering!"
-        for f in range(startFrame, endFrame+1):
+        print "Start Rendering of %d frames" % (endFrame-startFrame)
+        for f in xrange(startFrame, endFrame+1):
+            print "\n\nFrame: %d" % f

             context.currentFrame(f)
 
             context.currentFrame(f)
 

-            renderedScene = self.doRenderScene(self._SCENE)
+            # Use some temporary workspace, a full copy of the scene
+            inputScene = self._SCENE.copy(2)
+            # And Set our camera accordingly
+            self.cameraObj = inputScene.getCurrentCamera()
+
+            try:
+                renderedScene = self.doRenderScene(inputScene)
+            except :
+                print "There was an error! Aborting."
+                import traceback
+                print traceback.print_exc()
+
+                self._SCENE.makeCurrent()
+                Scene.unlink(inputScene)
+                del inputScene
+                return
+

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

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

             
             

-            # clear the rendered scene
+            # delete the rendered scene

             self._SCENE.makeCurrent()
             Scene.unlink(renderedScene)
             del renderedScene
 
         outputWriter.close()
         print "Done!"
             self._SCENE.makeCurrent()
             Scene.unlink(renderedScene)
             del renderedScene
 
         outputWriter.close()
         print "Done!"

-        context.currentFrame(currentFrame)
+        context.currentFrame(origCurrentFrame)

 
 
 
 

-    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)
-
-        # 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)
-

         # global processing of the scene
 
         # global processing of the scene
 

-        self._doConvertGeometricObjToMesh(workScene)
-

         self._doSceneClipping(workScene)
 
         self._doSceneClipping(workScene)
 

-        # FIXME: does not work in batch mode!
-        #if OPTIMIZE_FOR_SPACE:
-        #    self._joinMeshObjectsInScene(workScene)
+        self._doConvertGeometricObjsToMesh(workScene)
+
+        if config.output['JOIN_OBJECTS']:
+            self._joinMeshObjectsInScene(workScene)

 
         self._doSceneDepthSorting(workScene)
         
         # Per object activities
 
         Objects = workScene.getChildren()
 
         self._doSceneDepthSorting(workScene)
         
         # Per object activities
 
         Objects = workScene.getChildren()

-        for obj in Objects:
-            
+        print "Total Objects: %d" % len(Objects)
+        for i,obj in enumerate(Objects):
+            print "\n\n-------"
+            print "Rendering Object: %d" % i
+

             if obj.getType() != 'Mesh':
                 print "Only Mesh supported! - Skipping type:", obj.getType()
                 continue
 
             print "Rendering: ", obj.getName()
 
             if obj.getType() != 'Mesh':
                 print "Only Mesh supported! - Skipping type:", obj.getType()
                 continue
 
             print "Rendering: ", obj.getName()
 

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

 
 

-            self._doModelToWorldCoordinates(mesh, obj.matrix)
+            self._doModelingTransformation(mesh, obj.matrix)

 
 

-            self._doObjectDepthSorting(mesh)
-            

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

-            
-            self._doColorAndLighting(mesh)
+            if True:
+                for f in mesh.faces:
+                    f.sel = 1-f.sel
+                mesh.flipNormals()
+                for f in mesh.faces:
+                    f.sel = 1
+
+
+            self._doLighting(mesh)
+
+            # Do "projection" now so we perform further processing
+            # in Normalized View Coordinates
+            self._doProjection(mesh, self.proj)
+
+            self._doViewFrustumClipping(mesh)
+
+            self._doHiddenSurfaceRemoval(mesh)

 
 

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

 
 

-            self._doProjection(mesh, proj)

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


@@ -686,7 +1071,7 @@ class Renderer:
         """
         return obj.matrix.translationPart()
 
         """
         return obj.matrix.translationPart()
 

-    def _cameraViewDirection(self):
+    def _cameraViewVector(self):

         """Get the View Direction form the camera matrix.
         """
         return Vector(self.cameraObj.matrix[2]).resize3D()
         """Get the View Direction form the camera matrix.
         """
         return Vector(self.cameraObj.matrix[2]).resize3D()


@@ -721,7 +1106,7 @@ class Renderer:
         # View Vector in orthographics projections is the view Direction of
         # the camera
         if self.cameraObj.data.getType() == 1:
         # View Vector in orthographics projections is the view Direction of
         # the camera
         if self.cameraObj.data.getType() == 1:

-            view_vect = self._cameraViewDirection()
+            view_vect = self._cameraViewVector()

 
         # View vector in perspective projections can be considered as
         # the difference between the camera position and one point of
 
         # View vector in perspective projections can be considered as
         # the difference between the camera position and one point of


@@ -730,6 +1115,7 @@ class Renderer:
             vv = max( [ ((camPos - Vector(v.co)).length, (camPos - Vector(v.co))) for v in face] )
             view_vect = vv[1]
 
             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
         


@@ -741,36 +1127,14 @@ class Renderer:
 
     # Scene methods
 
 
     # Scene methods
 

-    def _doConvertGeometricObjToMesh(self, scene):
-        """Convert all "geometric" objects to mesh ones.
-        """
-        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)
-
-            # Mesh Cleanup
-            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):
     def _doSceneClipping(self, scene):

-        """Clip objects against the View Frustum.
+        """Clip whole objects against the View Frustum.

 
         For now clip away only objects according to their center position.
         """
 
         cpos = self._getObjPosition(self.cameraObj)
 
         For now clip away only objects according to their center position.
         """
 
         cpos = self._getObjPosition(self.cameraObj)

-        view_vect = self._cameraViewDirection()
+        view_vect = self._cameraViewVector()

 
         near = self.cameraObj.data.clipStart
         far  = self.cameraObj.data.clipEnd
 
         near = self.cameraObj.data.clipStart
         far  = self.cameraObj.data.clipEnd


@@ -792,6 +1156,34 @@ class Renderer:
             if (d < near) or (d > far) or (theta > fovy):
                 scene.unlink(o)
 
             if (d < near) or (d > far) or (theta > fovy):
                 scene.unlink(o)
 

+    def _doConvertGeometricObjsToMesh(self, scene):
+        """Convert all "geometric" objects to mesh ones.
+        """
+        #geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text']
+        geometricObjTypes = ['Mesh', 'Surf', 'Curve']
+
+        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 _doSceneDepthSorting(self, scene):
         """Sort objects in the scene.
 
     def _doSceneDepthSorting(self, scene):
         """Sort objects in the scene.
 


@@ -821,20 +1213,35 @@ class Renderer:
     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()
+
+        oList = [o for o in scene.getChildren() if o.getType()=='Mesh']
+
+        # FIXME: Object.join() do not work if the list contains 1 object
+        if len(oList) == 1:
+            return
+
+        mesh = Mesh.New('BigOne')

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

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

         scene.link(bigObj)
         scene.link(bigObj)

+
+        try:
+            bigObj.join(oList)
+        except RuntimeError:
+            print "\nWarning! - Can't Join Objects\n"
+            scene.unlink(bigObj)
+            return
+        except TypeError:
+            print "Objects Type error?"
+        

         for o in oList:
             scene.unlink(o)
 
         scene.update()
 
  
         for o in oList:
             scene.unlink(o)
 
         scene.update()
 
  

-    # Per object methods
+    # Per object/mesh methods

 
     def _convertToRawMeshObj(self, object):
         """Convert geometry based object to a mesh object.
 
     def _convertToRawMeshObj(self, object):
         """Convert geometry based object to a mesh object.


@@ -854,41 +1261,18 @@ class Renderer:
 
         return newObject
 
 
         return newObject
 

-    def _doModelToWorldCoordinates(self, mesh, matrix):
+    def _doModelingTransformation(self, mesh, matrix):

         """Transform object coordinates to world coordinates.
 
         This step is done simply applying to the object its tranformation
         matrix and recalculating its normals.
         """
         """Transform object coordinates to world coordinates.
 
         This step is done simply applying to the object its tranformation
         matrix and recalculating its normals.
         """

-        mesh.transform(matrix, True)
-
-    def _doObjectDepthSorting(self, mesh):
-        """Sort faces in an object.
-
-        The faces in the object are sorted following the distance of the
-        vertices from the camera position.
-        """
-        c = self._getObjPosition(self.cameraObj)
-
-        # hackish sorting of faces
+        # 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!"

 
 

-        # 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])))
-        
-        # 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()
+        mesh.transform(matrix, True)

 
     def _doBackFaceCulling(self, mesh):
         """Simple Backface Culling routine.
 
     def _doBackFaceCulling(self, mesh):
         """Simple Backface Culling routine.


@@ -909,41 +1293,24 @@ class Renderer:
             if self._isFaceVisible(f):
                 f.sel = 1
 
             if self._isFaceVisible(f):
                 f.sel = 1
 

-        # Is this the correct way to propagate the face selection info to the
-        # vertices belonging to a face ??
-        # 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;
-
-    def _doColorAndLighting(self, mesh):
-        """Apply an Illumination model to the object.
+    def _doLighting(self, mesh):
+        """Apply an Illumination and shading model to the object.

 
 

-        The Illumination model used is the Phong one, it may be inefficient,
+        The model used is the Phong one, it may be inefficient,

         but I'm just learning about rendering and starting from Phong seemed
         the most natural way.
         """
 
         # If the mesh has vertex colors already, use them,
         # otherwise turn them on and do some calculations
         but I'm just learning about rendering and starting from Phong seemed
         the most natural way.
         """
 
         # 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
 
         materials = mesh.materials

-        
-        # TODO: use multiple lighting sources
-        light_obj = self.lights[0]
-        light_pos = self._getObjPosition(light_obj)
-        light = light_obj.data

 
         camPos = self._getObjPosition(self.cameraObj)
 
         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
         # technique. For an example see:
         # We do per-face color calculation (FLAT Shading), we can easily turn
         # to a per-vertex calculation if we want to implement some shading
         # technique. For an example see:


@@ -959,52 +1326,495 @@ class Renderer:
             # A new default material
             if mat == None:
                 mat = Material.New('defMat')
             # A new default material
             if mat == None:
                 mat = Material.New('defMat')

+
+            # Check if it is a shadeless material
+            elif mat.getMode() & Material.Modes['SHADELESS']:
+                I = mat.getRGBCol()
+                # Convert to a value between 0 and 255
+                tmp_col = [ int(c * 255.0) for c in I]
+
+                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]
+
+                continue
+
+
+            # do vertex color calculation
+
+            TotDiffSpec = Vector([0.0, 0.0, 0.0])
+
+            for l in self.lights:
+                light_obj = l
+                light_pos = self._getObjPosition(l)
+                light = light_obj.data

             
             

-            L = Vector(light_pos).normalize()
+                L = Vector(light_pos).normalize()
+
+                V = (Vector(camPos) - Vector(f.cent)).normalize()
+
+                N = Vector(f.no).normalize()
+
+                if config.polygons['SHADING'] == 'TOON':
+                    NL = ShadingUtils.toonShading(N*L)
+                else:
+                    NL = (N*L)

 
 

-            V = (Vector(camPos) - Vector(f.v[0].co)).normalize()
+                # Should we use NL instead of (N*L) here?
+                R = 2 * (N*L) * N - L

 
 

-            N = Vector(f.no).normalize()
+                Ip = light.getEnergy()

 
 

-            R = 2 * (N*L) * N - L
+                # Diffuse co-efficient
+                kd = mat.getRef() * Vector(mat.getRGBCol())
+                for i in [0, 1, 2]:
+                    kd[i] *= light.col[i]
+
+                Idiff = Ip * kd * max(0, NL)
+
+
+                # Specular component
+                ks = mat.getSpec() * Vector(mat.getSpecCol())
+                ns = mat.getHardness()
+                Ispec = Ip * ks * pow(max(0, (V*R)), ns)
+
+                TotDiffSpec += (Idiff+Ispec)

 
 

-            # TODO: Attenuation factor (not used for now)
-            a0 = 1; a1 = 0.0; a2 = 0.0
-            d = (Vector(f.v[0].co) - Vector(light_pos)).length
-            fd = min(1, 1.0/(a0 + a1*d + a2*d*d))

 
             # Ambient component
 
             # Ambient component

-            Ia = 1.0
-            ka = mat.getAmb() * Vector([0.1, 0.1, 0.1])
-            Iamb = Ia * ka
-            
-            # Diffuse component (add light.col for kd)
-            kd = mat.getRef() * Vector(mat.getRGBCol())
-            Ip = light.getEnergy()
-            Idiff = Ip * kd * (N*L)
-            
-            # Specular component
-            ks = mat.getSpec() * Vector(mat.getSpecCol())
-            ns = mat.getHardness()
-            Ispec = Ip * ks * pow((V * R), ns)
+            Iamb = Vector(Blender.World.Get()[0].getAmb())
+            ka = mat.getAmb()

 
 

-            # Emissive component
+            # Emissive component (convert to a triplet)

             ki = Vector([mat.getEmit()]*3)
 
             ki = Vector([mat.getEmit()]*3)
 

-            I = ki + Iamb + Idiff + Ispec
+            #I = ki + Iamb + (Idiff + Ispec)
+            I = ki + (ka * Iamb) + TotDiffSpec
+
+
+            # 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]
 
             # Clamp I values between 0 and 1
             I = [ min(c, 1) for c in I]
             I = [ max(0, c) for c in I]

+
+            # Convert to a value between 0 and 255

             tmp_col = [ int(c * 255.0) 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 _doProjection(self, mesh, projector):
+        """Apply Viewing and Projection tranformations.
+        """
+
+        for v in mesh.verts:
+            p = projector.doProjection(v.co[:])
+            v.co[0] = p[0]
+            v.co[1] = p[1]
+            v.co[2] = p[2]
+
+        #mesh.recalcNormals()
+        #mesh.update()
+
+        # We could reeset Camera matrix, since now
+        # we are in Normalized Viewing Coordinates,
+        # but doung that would affect World Coordinate
+        # processing for other objects
+
+        #self.cameraObj.data.type = 1
+        #self.cameraObj.data.scale = 2.0
+        #m = Matrix().identity()
+        #self.cameraObj.setMatrix(m)
+
+    def _doViewFrustumClipping(self, mesh):
+        """Clip faces against the View Frustum.
+        """
+
+    # HSR routines
+    def __simpleDepthSort(self, mesh):
+        """Sort faces by the furthest vertex.
+
+        This simple mesthod is known also as the painter algorithm, and it
+        solves HSR correctly only for convex meshes.
+        """
+
+        global progress
+        # The sorting requires circa n*log(n) steps
+        n = len(mesh.faces)
+        progress.setActivity("HSR: Painter", n*log(n))
+        
+
+        by_furthest_z = (lambda f1, f2: progress.update() and
+                cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2]))
+                )
+
+        # FIXME: using NMesh to sort faces. We should avoid that!
+        nmesh = NMesh.GetRaw(mesh.name)
+
+        # remember that _higher_ z values mean further points
+        nmesh.faces.sort(by_furthest_z)
+        nmesh.faces.reverse()
+
+        nmesh.update()
+
+    def __topologicalDepthSort(self, mesh):
+        """Occlusion based on topological occlusion.
+        
+        Build the occlusion graph of the mesh,
+        and then do topological sort on that graph
+        """
+        return
+
+    def __newellDepthSort(self, mesh):
+        """Newell's depth sorting.
+
+        """
+        by_furthest_z = (lambda f1, f2:
+                cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2]))
+                )
+
+        mesh.quadToTriangle(0)
+
+        from split import Distance, isOnSegment
+
+        def projectionsOverlap(P, Q):
+
+            for i in range(0, len(P.v)):
+
+                v1 = Vector(P.v[i-1])
+                v1[2] = 0
+                v2 = Vector(P.v[i])
+                v2[2] = 0
+
+                EPS = 10e-7
+
+                for j in range(0, len(Q.v)):
+                    v3 = Vector(Q.v[j-1])
+                    v3[2] = 0
+                    v4 = Vector(Q.v[j])
+                    v4[2] = 0
+                    
+                    ret = LineIntersect(v1, v2, v3, v4)
+                    # if line v1-v2 and v3-v4 intersect both return
+                    # values are the same.
+                    if ret and ret[0] == ret[1]  and isOnSegment(v1, v2,
+                            ret[0], True) and isOnSegment(v3, v4, ret[1], True):
+
+
+                        l1 = (ret[0] - v1).length
+                        l2 = (ret[0] - v2).length
+
+                        l3 = (ret[1] - v3).length
+                        l4 = (ret[1] - v4).length
+
+                        if  (l1 < EPS or l2 < EPS) and (l3 < EPS or l4 < EPS):
+                            continue
+
+                        debug("Projections OVERLAP!!\n")
+                        debug("line1:"+
+                                " M "+ str(v1[0])+','+str(v1[1]) + ' L ' + str(v2[0])+','+str(v2[1]) + '\n' +
+                                " M "+ str(v3[0])+','+str(v3[1]) + ' L ' + str(v4[0])+','+str(v4[1]) + '\n' +
+                                "\n")
+                        debug("return: "+ str(ret)+"\n")
+                        return True
+
+            return False
+
+
+        from facesplit import facesplit
+
+        # FIXME: using NMesh to sort faces. We should avoid that!
+        nmesh = NMesh.GetRaw(mesh.name)
+
+        # remember that _higher_ z values mean further points
+        nmesh.faces.sort(by_furthest_z)
+        nmesh.faces.reverse()
+
+        
+        # Begin depth sort tests
+
+        # use the smooth flag to set marked faces
+        for f in nmesh.faces:
+            f.smooth = 0
+
+        facelist = nmesh.faces[:]
+        maplist = []

 
 

-    def _doEdgesStyle(self, mesh, style):
-        """Process Mesh Edges.
+        EPS = 10e-8
+        #EPS = 0
+
+        global progress
+        # The steps are _at_least_ equal to len(facelist), we do not count the
+        # feces coming out from plitting!!
+        progress.setActivity("HSR: Newell", len(facelist))
+        progress.setQuiet(True)
+
+        
+        steps = -1
+        split_done = 0
+        marked_face = 0
+
+        while len(facelist):
+            print "\n----------------------"
+            P = facelist[0]
+            
+            #steps += 1
+            #if steps == 3:
+            #    maplist = facelist
+            #    break
+            print len(facelist)
+            if len(facelist) == 33:
+                #maplist = facelist
+                break
+
+
+            #pSign = 1
+            #if P.normal[2] < 0:
+            #    pSign = -1
+            pSign = sign(P.normal[2])
+
+            # We can discard faces thar are perpendicular to the view
+            if pSign == 0:
+                facelist.remove(P)
+                continue
+
+
+            split_done = 0
+            face_marked = 0
+
+            for Q in facelist[1:]:
+
+                debug("P.smooth: " + str(P.smooth) + "\n")
+                debug("Q.smooth: " + str(Q.smooth) + "\n")
+                debug("\n")
+
+                #qSign = 1
+                #if Q.normal[2] < 0:
+                #    qSign = -1
+                qSign = sign(Q.normal[2])
+ 
+                # We need to test only those Qs whose furthest vertex
+                # is closer to the observer than the closest vertex of P.
+
+                zP = [v.co[2] for v in P.v]
+                zQ = [v.co[2] for v in Q.v]
+                ZOverlap = min(zP) < max(zQ)
+
+                if not ZOverlap:
+                    debug("\nTest 0\n")
+                    debug("NOT Z OVERLAP!\n")
+                    if Q.smooth == 0:
+                        # If Q is not marked then we can safely print P
+                        break
+                    else:
+                        debug("met a marked face\n")
+                        continue
+                
+                # Test 1: X extent overlapping
+                xP = [v.co[0] for v in P.v]
+                xQ = [v.co[0] for v in Q.v]
+                notXOverlap = (max(xP) <= min(xQ)) or (max(xQ) <= min(xP))
+
+                if notXOverlap:
+                    debug("\nTest 1\n")
+                    debug("NOT X OVERLAP!\n")
+                    continue
+
+                # Test 2: Y extent Overlapping
+                yP = [v.co[1] for v in P.v]
+                yQ = [v.co[1] for v in Q.v]
+                notYOverlap = (max(yP) <= min(yQ)) or (max(yQ) <= min(yP))
+
+                if notYOverlap:
+                    debug("\nTest 2\n")
+                    debug("NOT Y OVERLAP!\n")
+                    continue
+                
+
+                # Test 3: P vertices are all behind the plane of Q
+                n = 0
+                for Pi in P:
+                    d = qSign * Distance(Vector(Pi), Q)
+                    if d >= -EPS:
+                        n += 1
+                pVerticesBehindPlaneQ = (n == len(P))
+
+                if pVerticesBehindPlaneQ:
+                    debug("\nTest 3\n")
+                    debug("P BEHIND Q!\n")
+                    continue
+
+
+                # Test 4: Q vertices in front of the plane of P
+                n = 0
+                for Qi in Q:
+                    d = pSign * Distance(Vector(Qi), P)
+                    if d <= EPS:
+                        n += 1
+                qVerticesInFrontPlaneP = (n == len(Q))
+
+                if qVerticesInFrontPlaneP:
+                    debug("\nTest 4\n")
+                    debug("Q IN FRONT OF P!\n")
+                    continue
+
+                # Test 5: Line Intersections... TODO
+                # Check if polygons effectively overlap each other, not only
+                # boundig boxes as done before.
+                # Since we We are working in normalized projection coordinates
+                # we kust check if polygons intersect.
+
+                if not projectionsOverlap(P, Q):
+                    debug("\nTest 5\n")
+                    debug("Projections do not overlap!\n")
+                    continue
+
+
+                # We still do not know if P obscures Q.
+
+                # But if Q is marked we do a split trying to resolve a
+                # difficulty (maybe a visibility cycle).
+                if Q.smooth == 1:
+                    # Split P or Q
+                    debug("Possibly a cycle detected!\n")
+                    debug("Split here!!\n")
+                    old_facelist = facelist[:]
+                    facelist = facesplit(P, Q, facelist, nmesh)
+                    split_done = 1
+                    break 
+
+
+                # The question now is: Does Q obscure P?
+
+                # Test 3bis: Q vertices are all behind the plane of P
+                n = 0
+                for Qi in Q:
+                    d = pSign * Distance(Vector(Qi), P)
+                    if d >= -EPS:
+                        n += 1
+                qVerticesBehindPlaneP = (n == len(Q))
+
+                if qVerticesBehindPlaneP:
+                    debug("\nTest 3bis\n")
+                    debug("Q BEHIND P!\n")
+
+
+                # Test 4bis: P vertices in front of the plane of Q
+                n = 0
+                for Pi in P:
+                    d = qSign * Distance(Vector(Pi), Q)
+                    if d <= EPS:
+                        n += 1
+                pVerticesInFrontPlaneQ = (n == len(P))
+
+                if pVerticesInFrontPlaneQ:
+                    debug("\nTest 4bis\n")
+                    debug("P IN FRONT OF Q!\n")
+
+                
+                # We don't even know if Q does obscure P, so they should
+                # intersect each other, split one of them in two parts.
+                if not qVerticesBehindPlaneP and not pVerticesInFrontPlaneQ:
+                    debug("\nSimple Intersection?\n")
+                    debug("Test 3bis or 4bis failed\n")
+                    debug("Split here!!2\n")
+
+                    old_facelist = facelist[:]
+                    facelist = facesplit(P, Q, facelist, nmesh)
+
+                    steps += 1
+                    if steps == 2:
+                        maplist = [P, Q]
+                        print P, Q
+                    split_done = 1
+                    break 
+
+                    
+                facelist.remove(Q)
+                facelist.insert(0, Q)
+                Q.smooth = 1
+                face_marked = 1
+
+                # Make merked faces BLUE. so to see them
+                #for c in Q.col:
+                #    c.r = 0
+                #    c.g = 0
+                #    c.b = 255
+                #    c.a = 255
+                
+                debug("Q marked!\n")
+                print [f.smooth for f in facelist]
+                break
+           
+            # Write P!                     
+            if split_done == 0 and face_marked == 0:
+                P = facelist[0]
+                facelist.remove(P)
+                maplist.append(P)
+
+                progress.update()
+                #if progress.progressModel.getProgress() == 100:
+                #    break
+            if steps == 2:
+                """
+                for c in Q.col:
+                    c.r = 0
+                    c.g = 0
+                    c.b = 255
+                    c.a = 255
+                for c in P.col:
+                    c.r = 0
+                    c.g = 0
+                    c.b = 255
+                    c.a = 255
+                """
+                print steps
+                #maplist.append(P)
+                #maplist.append(Q)
+
+               # for f in facelist:
+               #     if f not in old_facelist:
+               #         print "splitted?"
+               #         maplist.append(f)
+
+                break
+            """
+            """
+
+         
+
+        nmesh.faces = maplist
+
+        for f in nmesh.faces:
+            f.sel = 1
+        nmesh.update()
+        print nmesh.faces
+
+    def _doHiddenSurfaceRemoval(self, mesh):
+        """Do HSR for the given mesh.
+        """
+        if len(mesh.faces) == 0:
+            return
+
+        if config.polygons['HSR'] == 'PAINTER':
+            print "\nUsing the Painter algorithm for HSR."
+            self.__simpleDepthSort(mesh)
+
+        elif config.polygons['HSR'] == 'NEWELL':
+            print "\nUsing the Newell's algorithm for HSR."
+            self.__newellDepthSort(mesh)
+
+
+    def _doEdgesStyle(self, mesh, edgestyleSelect):
+        """Process Mesh Edges accroding to a given selection style.

 
         Examples of algorithms:
 
 
         Examples of algorithms:
 


@@ -1016,62 +1826,298 @@ class Renderer:
             given an edge if one its adjacent faces is frontfacing and the
             other is backfacing, than select it, else deselect.
         """
             given an edge if one its adjacent faces is frontfacing and the
             other is backfacing, than select it, else deselect.
         """

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

 
 

-    def _doProjection(self, mesh, projector):
-        """Calculate the Projection for the object.
-        """
-        # TODO: maybe using the object.transform() can be faster?
+        Mesh.Mode(Mesh.SelectModes['EDGE'])

 
 

-        for v in mesh.verts:
-            p = projector.doProjection(v.co)
-            v.co[0] = p[0]
-            v.co[1] = p[1]
-            v.co[2] = p[2]
+        edge_cache = MeshUtils.buildEdgeFaceUsersCache(mesh)
+
+        for i,edge_faces in enumerate(edge_cache):
+            mesh.edges[i].sel = 0
+            if edgestyleSelect(edge_faces):
+                mesh.edges[i].sel = 1

 
 

+        """
+        for e in mesh.edges:
+
+            e.sel = 0
+            if edgestyleSelect(e, mesh):
+                e.sel = 1
+        """
+                

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

-## 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['JOIN_OBJECTS'])
+        GUI.evtJoinObjsToggle = 2
+
+        # Render filled polygons
+        GUI.polygonsToggle = Draw.Create(config.polygons['SHOW'])
+
+        # Shading Style menu 
+        shading_style = config.polygons['SHADING']
+        default_value = shadingStyles.keys().index(shading_style)+1
+        GUI.shadingStyleMenu = Draw.Create(default_value)
+        GUI.evtShadingStyleMenu = 21
+
+        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 = edgeStyles.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
+
+        # Edge Color Picker
+        c = config.edges['COLOR']
+        GUI.edgeColorPicker = Draw.Create(c[0]/255.0, c[1]/255.0, c[2]/255.0)
+        GUI.evtEdgeColorPicker = 71
+
+        # 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. Version %s." %
+                __version__)
+        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")
+
+        if GUI.polygonsToggle.val == 1:
+
+            # Polygon Shading Style
+            shadingStyleMenuStruct = "Shading Style %t"
+            for t in shadingStyles.keys():
+                shadingStyleMenuStruct = shadingStyleMenuStruct + "|%s" % t.lower()
+            GUI.shadingStyleMenu = Draw.Menu(shadingStyleMenuStruct, GUI.evtShadingStyleMenu,
+                    200, 260, 160, 18, GUI.shadingStyleMenu.val,
+                    "Choose the shading style")
+
+
+        # Render Edges
+        GUI.showEdgesToggle = Draw.Toggle("Show Edges", GUI.evtShowEdgesToggle,
+                200, 235, 160, 18, GUI.showEdgesToggle.val,
+                "Render polygon edges")
+
+        if GUI.showEdgesToggle.val == 1:
+            
+            # Edge Style
+            edgeStyleMenuStruct = "Edge Style %t"
+            for t in edgeStyles.keys():
+                edgeStyleMenuStruct = edgeStyleMenuStruct + "|%s" % t.lower()
+            GUI.edgeStyleMenu = Draw.Menu(edgeStyleMenuStruct, GUI.evtEdgeStyleMenu,
+                    200, 210, 160, 18, GUI.edgeStyleMenu.val,
+                    "Choose the edge style")
+
+            # Edge size
+            GUI.edgeWidthSlider = Draw.Slider("Width: ", GUI.evtEdgeWidthSlider,
+                    200, 185, 140, 18, GUI.edgeWidthSlider.val,
+                    0.0, 10.0, 0, "Change Edge Width")
+
+            # Edge Color
+            GUI.edgeColorPicker = Draw.ColorPicker(GUI.evtEdgeColorPicker,
+                    342, 185, 18, 18, GUI.edgeColorPicker.val, "Choose Edge Color")
+
+            # Show Hidden Edges
+            GUI.showHiddenEdgesToggle = Draw.Toggle("Show Hidden Edges",
+                    GUI.evtShowHiddenEdgesToggle,
+                    200, 160, 160, 18, GUI.showHiddenEdgesToggle.val,
+                    "Render hidden edges as dashed lines")
+
+        glRasterPos2i(10, 160)
+        Draw.Text("%s (c) 2006" % __author__)
+
+    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.output['ANIMATION'] = bool(GUI.animToggle.val)
+
+        elif evt == GUI.evtJoinObjsToggle:
+            config.output['JOIN_OBJECTS'] = bool(GUI.joinObjsToggle.val)
+
+        elif evt == GUI.evtPolygonsToggle:
+            config.polygons['SHOW'] = bool(GUI.polygonsToggle.val)
+
+        elif evt == GUI.evtShadingStyleMenu:
+            i = GUI.shadingStyleMenu.val - 1
+            config.polygons['SHADING'] = shadingStyles.keys()[i]
+
+        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'] = edgeStyles.keys()[i]
+
+        elif evt == GUI.evtEdgeWidthSlider:
+            config.edges['WIDTH'] = float(GUI.edgeWidthSlider.val)
+
+        elif evt == GUI.evtEdgeColorPicker:
+            config.edges['COLOR'] = [int(c*255.0) for c in GUI.edgeColorPicker.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
+        print "\nConfig"
+        pprint(config.output)
+        pprint(config.polygons)
+        pprint(config.edges)
+
+    _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()
-
+# We use a global progress Indicator Object
+progress = None

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

-    
+
+    global progress
+
+    outputfile = ""

     basename = Blender.sys.basename(Blender.Get('filename'))
     basename = Blender.sys.basename(Blender.Get('filename'))

-    outputfile = Blender.sys.splitext(basename)[0]+".svg"
+    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':
+        progress = ConsoleProgressIndicator()

         vectorize(outputfile)
         vectorize(outputfile)

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