Release version 0.3, the last supporting blender 2.4x

[vrm.git] / vrm.py

diff --git a/vrm.py b/vrm.py
index 7324efc..86c8fba 100755 (executable)
--- a/vrm.py
+++ b/vrm.py
@@ -1,21 +1,21 @@
 #!BPY
 """
 Name: 'VRM'
 #!BPY
 """
 Name: 'VRM'

-Blender: 242
+Blender: 245

 Group: 'Render'
 Tooltip: 'Vector Rendering Method script'
 """
 
 __author__ = "Antonio Ospite"
 Group: 'Render'
 Tooltip: 'Vector Rendering Method script'
 """
 
 __author__ = "Antonio Ospite"

-__url__ = ["http://projects.blender.org/projects/vrm"]
-__version__ = "0.3.beta"
+__url__ = ["http://vrm.ao2.it"]
+__version__ = "0.3"

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

-#    Copyright (c) 2006 Antonio Ospite
+#    Copyright (c) 2006, 2007, 2008, 2009, 2012 Antonio Ospite

 #
 #    This program is free software; you can redistribute it and/or modify
 #    it under the terms of the GNU General Public License as published by
 #
 #    This program is free software; you can redistribute it and/or modify
 #    it under the terms of the GNU General Public License as published by


@@ -40,13 +40,14 @@ __bpydoc__ = """\
 #       from scratch but Nikola gave me the idea, so I thank him publicly.
 #
 # ---------------------------------------------------------------------
 #       from scratch but Nikola gave me the idea, so I thank him publicly.
 #
 # ---------------------------------------------------------------------

-# 
+#

 # Things TODO for a next release:
 # Things TODO for a next release:

+#   - Shadeless shader

 #   - FIX the issue with negative scales in object tranformations!
 #   - Use a better depth sorting algorithm
 #   - Review how selections are made (this script uses selection states of
 #     primitives to represent visibility infos)
 #   - FIX the issue with negative scales in object tranformations!
 #   - Use a better depth sorting algorithm
 #   - Review how selections are made (this script uses selection states of
 #     primitives to represent visibility infos)

-#   - Use a data structure other than Mesh to represent the 2D image? 
+#   - 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
 #     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


@@ -60,38 +61,26 @@ __bpydoc__ = """\
 #   - Check memory use!!
 #
 # ---------------------------------------------------------------------
 #   - Check memory use!!
 #
 # ---------------------------------------------------------------------

-#
-# Changelog:
-#
-#   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.
-#     * Initial SWF output support (using ming)
-#     * Fixed a bug in the animation code, now the projection matrix is
-#       recalculated at each frame!
-#     * PDF output (using reportlab)
-#     * Fixed another problem in the animation code the current frame was off
-#       by one in the case of camera movement.
-#     * Use fps as specified in blender when VectorWriter handles animation
-#     * Remove the real file opening in the abstract VectorWriter
-#     * View frustum clipping
-#     * Scene clipping done using bounding box instead of object center
-#     * Fix camera type selection for blender>2.43 (Thanks to Thomas Lachmann)
-#
-# ---------------------------------------------------------------------

 
 import Blender
 from Blender import Scene, Object, Mesh, NMesh, Material, Lamp, Camera, Window
 from Blender.Mathutils import *
 from math import *
 
 import Blender
 from Blender import Scene, Object, Mesh, NMesh, Material, Lamp, Camera, Window
 from Blender.Mathutils import *
 from math import *

-import sys, time
+import sys
+import time
+
+try:
+    set()
+except NameError:
+    from sets import Set as set
+
+
+def uniq(alist):
+    tmpdict = dict()
+    return [tmpdict.setdefault(e, e) for e in alist if e not in tmpdict]
+    # in python > 2.4 we ca use the following
+    #return [ u for u in alist if u not in locals()['_[1]'] ]
+

 
 # Constants
 EPS = 10e-5
 
 # Constants
 EPS = 10e-5


@@ -100,13 +89,13 @@ EPS = 10e-5
 progress = None
 
 
 progress = None
 
 

-# Some global settings
+# Config class for global settings

 
 class config:
     polygons = dict()
     polygons['SHOW'] = True
 
 class config:
     polygons = dict()
     polygons['SHOW'] = True

-    polygons['SHADING'] = 'FLAT' # FLAT or TOON
-    polygons['HSR'] = 'NEWELL' # PAINTER or NEWELL
+    polygons['SHADING'] = 'FLAT'  # FLAT or TOON
+    polygons['HSR'] = 'PAINTER'  # PAINTER or NEWELL

     # Hidden to the user for now
     polygons['EXPANSION_TRICK'] = True
 
     # Hidden to the user for now
     polygons['EXPANSION_TRICK'] = True
 


@@ -115,7 +104,7 @@ class config:
     edges = dict()
     edges['SHOW'] = False
     edges['SHOW_HIDDEN'] = False
     edges = dict()
     edges['SHOW'] = False
     edges['SHOW_HIDDEN'] = False

-    edges['STYLE'] = 'MESH' # MESH or SILHOUETTE
+    edges['STYLE'] = 'MESH'  # MESH or SILHOUETTE

     edges['WIDTH'] = 2
     edges['COLOR'] = [0, 0, 0]
 
     edges['WIDTH'] = 2
     edges['COLOR'] = [0, 0, 0]
 


@@ -124,10 +113,46 @@ class config:
     output['ANIMATION'] = False
     output['JOIN_OBJECTS'] = True
 
     output['ANIMATION'] = False
     output['JOIN_OBJECTS'] = True
 

+    def saveToRegistry():
+        registry = {}
+
+        for k, v in config.__dict__.iteritems():
+
+            # config class store settings in dictionaries
+            if v.__class__ == dict().__class__:
+
+                regkey_prefix = k.upper() + "_"
+
+                for opt_k, opt_v in v.iteritems():
+                    regkey = regkey_prefix + opt_k
+
+                    registry[regkey] = opt_v
+
+        Blender.Registry.SetKey('VRM', registry, True)
+
+    saveToRegistry = staticmethod(saveToRegistry)
+
+    def loadFromRegistry():
+        registry = Blender.Registry.GetKey('VRM', True)
+        if not registry:
+            return
+
+        for k, v in registry.iteritems():
+            k_tmp = k.split('_')
+            conf_attr = k_tmp[0].lower()
+            conf_key = str.join("_", k_tmp[1:])
+            conf_val = v
+
+            if conf_attr in config.__dict__:
+                config.__dict__[conf_attr][conf_key] = conf_val
+
+    loadFromRegistry = staticmethod(loadFromRegistry)
+

 
 # Utility functions
 print_debug = False
 
 
 # Utility functions
 print_debug = False
 

+

 def dumpfaces(flist, filename):
     """Dump a single face to a file.
     """
 def dumpfaces(flist, filename):
     """Dump a single face to a file.
     """


@@ -147,17 +172,20 @@ def dumpfaces(flist, filename):
 
     writerobj.close()
 
 
     writerobj.close()
 

+

 def debug(msg):
     if print_debug:
         sys.stderr.write(msg)
 
 def debug(msg):
     if print_debug:
         sys.stderr.write(msg)
 

+

 def EQ(v1, v2):
 def EQ(v1, v2):

-    return (abs(v1[0]-v2[0]) < EPS and 
-            abs(v1[1]-v2[1]) < EPS )
+    return (abs(v1[0] - v2[0]) < EPS and
+            abs(v1[1] - v2[1]) < EPS)

 by_furthest_z = (lambda f1, f2:
 by_furthest_z = (lambda f1, f2:

-    cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2])+EPS)
+    cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2]) + EPS)

     )
 
     )
 

+

 def sign(x):
 
     if x < -EPS:
 def sign(x):
 
     if x < -EPS:


@@ -179,6 +207,7 @@ def sign(x):
 EPS = 10e-5
 INF = 10e5
 
 EPS = 10e-5
 INF = 10e5
 

+

 class HSR:
     """A utility class for HSR processing.
     """
 class HSR:
     """A utility class for HSR processing.
     """


@@ -189,18 +218,18 @@ class HSR:
         From: http://mathworld.wolfram.com/Coplanar.html
 
         Geometric objects lying in a common plane are said to be coplanar.
         From: http://mathworld.wolfram.com/Coplanar.html
 
         Geometric objects lying in a common plane are said to be coplanar.

-        Three noncollinear points determine a plane and so are trivially coplanar.
-        Four points are coplanar iff the volume of the tetrahedron defined by them is
-        0, 
-        
+        Three noncollinear points determine a plane and so are trivially
+        coplanar. Four points are coplanar iff the volume of the tetrahedron
+        defined by them is 0,
+

             | x_1 y_1 z_1 1 |
             | x_2 y_2 z_2 1 |
             | x_3 y_3 z_3 1 |
             | x_4 y_4 z_4 1 | == 0
 
         Coplanarity is equivalent to the statement that the pair of lines
             | x_1 y_1 z_1 1 |
             | x_2 y_2 z_2 1 |
             | x_3 y_3 z_3 1 |
             | x_4 y_4 z_4 1 | == 0
 
         Coplanarity is equivalent to the statement that the pair of lines

-        determined by the four points are not skew, and can be equivalently stated
-        in vector form as (x_3-x_1).[(x_2-x_1)x(x_4-x_3)]==0.
+        determined by the four points are not skew, and can be equivalently
+        stated in vector form as (x_3-x_1).[(x_2-x_1)x(x_4-x_3)]==0.

 
         An arbitrary number of n points x_1, ..., x_n can be tested for
         coplanarity by finding the point-plane distances of the points
 
         An arbitrary number of n points x_1, ..., x_n can be tested for
         coplanarity by finding the point-plane distances of the points


@@ -220,13 +249,13 @@ class HSR:
         elif n == 3:
             # three points must be complanar
             return False
         elif n == 3:
             # three points must be complanar
             return False

-        else: # n == 4
+        else:  # n == 4

             x1 = Vector(face[0].co)
             x2 = Vector(face[1].co)
             x3 = Vector(face[2].co)
             x4 = Vector(face[3].co)
 
             x1 = Vector(face[0].co)
             x2 = Vector(face[1].co)
             x3 = Vector(face[2].co)
             x4 = Vector(face[3].co)
 

-            v = (x3-x1) * CrossVecs((x2-x1), (x4-x3))
+            v = (x3 - x1) * CrossVecs((x2 - x1), (x4 - x3))

             if v != 0:
                 return True
 
             if v != 0:
                 return True
 


@@ -252,25 +281,24 @@ class HSR:
         #z3 = s2[0].co[2]
         #z4 = s2[1].co[2]
 
         #z3 = s2[0].co[2]
         #z4 = s2[1].co[2]
 

-

         # calculate delta values (vector components)
         # calculate delta values (vector components)

-        dx1 = x2 - x1;
-        dx2 = x4 - x3;
-        dy1 = y2 - y1;
-        dy2 = y4 - y3;
+        dx1 = x2 - x1
+        dx2 = x4 - x3
+        dy1 = y2 - y1
+        dy2 = y4 - y3

 
 

-        #dz1 = z2 - z1;
-        #dz2 = z4 - z3;
+        #dz1 = z2 - z1
+        #dz2 = z4 - z3

 
 

-        C = dy2 * dx1 - dx2 * dy1 #  /* cross product */
-        if C == 0:  #/* parallel */
+        C = dy2 * dx1 - dx2 * dy1  # cross product
+        if C == 0:  # parallel

             return None
 
             return None
 

-        dx3 = x1 - x3 # /* combined origin offset vector */
+        dx3 = x1 - x3  # combined origin offset vector

         dy3 = y1 - y3
 
         dy3 = y1 - y3
 

-        a1 = (dy3 * dx2 - dx3 * dy2) / C;
-        a2 = (dy3 * dx1 - dx3 * dy1) / C;
+        a1 = (dy3 * dx2 - dx3 * dy2) / C
+        a2 = (dy3 * dx1 - dx3 * dy1) / C

 
         # check for degeneracies
         #print_debug("\n")
 
         # check for degeneracies
         #print_debug("\n")


@@ -281,11 +309,11 @@ class HSR:
             # Intersection on boundaries, we consider the point external?
             return None
 
             # Intersection on boundaries, we consider the point external?
             return None
 

-        elif (a1>0.0 and a1<1.0 and a2>0.0 and a2<1.0): #  /* lines cross */
-            x = x1 + a1*dx1
-            y = y1 + a1*dy1
+        elif (a1 > 0.0 and a1 < 1.0 and a2 > 0.0 and a2 < 1.0):  # lines cross
+            x = x1 + a1 * dx1
+            y = y1 + a1 * dy1

 
 

-            #z = z1 + a1*dz1
+            #z = z1 + a1 * dz1

             z = 0
             return (NMesh.Vert(x, y, z), a1, a2)
 
             z = 0
             return (NMesh.Vert(x, y, z), a1, a2)
 


@@ -304,7 +332,7 @@ class HSR:
 
         for i in range(len(self.v)):
             s1 = (point_at_infinity, v)
 
         for i in range(len(self.v)):
             s1 = (point_at_infinity, v)

-            s2 = (self.v[i-1], self.v[i])
+            s2 = (self.v[i - 1], self.v[i])

 
             if EQ(v.co, s2[0].co) or EQ(v.co, s2[1].co):
                 coincidence = True
 
             if EQ(v.co, s2[0].co) or EQ(v.co, s2[1].co):
                 coincidence = True


@@ -313,7 +341,7 @@ class HSR:
                 winding_number += 1
 
         # Check even or odd
                 winding_number += 1
 
         # Check even or odd

-        if winding_number % 2 == 0 :
+        if (winding_number % 2) == 0:

             return False
         else:
             if coincidence:
             return False
         else:
             if coincidence:


@@ -322,11 +350,10 @@ class HSR:
 
     isVertInside = staticmethod(isVertInside)
 
 
     isVertInside = staticmethod(isVertInside)
 

-

     def det(a, b, c):
         return ((b[0] - a[0]) * (c[1] - a[1]) -
     def det(a, b, c):
         return ((b[0] - a[0]) * (c[1] - a[1]) -

-                (b[1] - a[1]) * (c[0] - a[0]) )
-    
+                (b[1] - a[1]) * (c[0] - a[0]))
+

     det = staticmethod(det)
 
     def pointInPolygon(q, P):
     det = staticmethod(det)
 
     def pointInPolygon(q, P):


@@ -337,13 +364,13 @@ class HSR:
         det = HSR.det
 
         for i in range(len(P.v)):
         det = HSR.det
 
         for i in range(len(P.v)):

-            p0 = P.v[i-1]
+            p0 = P.v[i - 1]

             p1 = P.v[i]
             p1 = P.v[i]

-            if (det(q.co, point_at_infinity.co, p0.co)<0) != (det(q.co, point_at_infinity.co, p1.co)<0):
-                if det(p0.co, p1.co, q.co) == 0 :
+            if (det(q.co, point_at_infinity.co, p0.co) < 0) != (det(q.co, point_at_infinity.co, p1.co) < 0):
+                if det(p0.co, p1.co, q.co) == 0:

                     #print "On Boundary"
                     return False
                     #print "On Boundary"
                     return False

-                elif (det(p0.co, p1.co, q.co)<0) != (det(p0.co, p1.co, point_at_infinity.co)<0):
+                elif (det(p0.co, p1.co, q.co) < 0) != (det(p0.co, p1.co, point_at_infinity.co) < 0):

                     is_in = not is_in
 
         return is_in
                     is_in = not is_in
 
         return is_in


@@ -363,7 +390,6 @@ class HSR:
 
         for i in range(len(f1.v)):
 
 
         for i in range(len(f1.v)):
 

-

             # If a point of f1 in inside f2, there is an overlap!
             v1 = f1.v[i]
             #if HSR.isVertInside(f2, v1):
             # If a point of f1 in inside f2, there is an overlap!
             v1 = f1.v[i]
             #if HSR.isVertInside(f2, v1):


@@ -373,10 +399,10 @@ class HSR:
             # If not the polygon can be ovelap as well, so we check for
             # intersection between an edge of f1 and all the edges of f2
 
             # If not the polygon can be ovelap as well, so we check for
             # intersection between an edge of f1 and all the edges of f2
 

-            v0 = f1.v[i-1]
+            v0 = f1.v[i - 1]

 
             for j in range(len(f2.v)):
 
             for j in range(len(f2.v)):

-                v2 = f2.v[j-1]
+                v2 = f2.v[j - 1]

                 v3 = f2.v[j]
 
                 e1 = v0, v1
                 v3 = f2.v[j]
 
                 e1 = v0, v1


@@ -410,7 +436,7 @@ class HSR:
         """
 
         by_furthest_z = (lambda f1, f2:
         """
 
         by_furthest_z = (lambda f1, f2:

-                cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2])+EPS)
+                cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2]) + EPS)

                 )
 
         # Choose if split P on Q plane or vice-versa
                 )
 
         # Choose if split P on Q plane or vice-versa


@@ -474,7 +500,6 @@ class HSR:
             #
             #newfaces = splitOn(plane, f)
 
             #
             #newfaces = splitOn(plane, f)
 

-        

         if newfaces == None:
             print "Big FAT problem, we weren't able to split POLYGONS!"
             raise AssertionError
         if newfaces == None:
             print "Big FAT problem, we weren't able to split POLYGONS!"
             raise AssertionError


@@ -514,8 +539,8 @@ class HSR:
         """Check if point p is in segment v1v2.
         """
 
         """Check if point p is in segment v1v2.
         """
 

-        l1 = (v1-p).length
-        l2 = (v2-p).length
+        l1 = (v1 - p).length
+        l2 = (v2 - p).length

 
         # Should we consider extreme points as internal ?
         # The test:
 
         # Should we consider extreme points as internal ?
         # The test:


@@ -523,10 +548,10 @@ class HSR:
         if l1 < EPS or l2 < EPS:
             return extremes_internal
 
         if l1 < EPS or l2 < EPS:
             return extremes_internal
 

-        l = (v1-v2).length
+        l = (v1 - v2).length

 
         # if the sum of l1 and l2 is circa l, then the point is on segment,
 
         # if the sum of l1 and l2 is circa l, then the point is on segment,

-        if abs(l - (l1+l2)) < EPS:
+        if abs(l - (l1 + l2)) < EPS:

             return True
         else:
             return False
             return True
         else:
             return False


@@ -599,16 +624,15 @@ class HSR:
         """
 
         # Check if P and Q are parallel
         """
 
         # Check if P and Q are parallel

-        u = CrossVecs(Vector(Q.no),Vector(P.no))
+        u = CrossVecs(Vector(Q.no), Vector(P.no))

         ax = abs(u[0])
         ay = abs(u[1])
         az = abs(u[2])
 
         ax = abs(u[0])
         ay = abs(u[1])
         az = abs(u[2])
 

-        if (ax+ay+az) < EPS:
+        if (ax + ay + az) < EPS:

             print "PARALLEL planes!!"
             return
 
             print "PARALLEL planes!!"
             return
 

-

         # The final aim is to find the intersection line between P
         # and the plane of Q, and split P along this line
 
         # The final aim is to find the intersection line between P
         # and the plane of Q, and split P along this line
 


@@ -624,15 +648,15 @@ class HSR:
         posVertList = []
         negVertList = []
         for i in range(nP):
         posVertList = []
         negVertList = []
         for i in range(nP):

-            d0 = d[i-1]
-            V0 = P.v[i-1]
+            d0 = d[i - 1]
+            V0 = P.v[i - 1]

 
             d1 = d[i]
             V1 = P.v[i]
 
             #print "d0:", d0, "d1:", d1
 
 
             d1 = d[i]
             V1 = P.v[i]
 
             #print "d0:", d0, "d1:", d1
 

-            # if the vertex lies in the cutplane                       
+            # if the vertex lies in the cutplane

             if abs(d1) < EPS:
                 #print "d1 On cutplane"
                 posVertList.append(V1)
             if abs(d1) < EPS:
                 #print "d1 On cutplane"
                 posVertList.append(V1)


@@ -649,7 +673,7 @@ class HSR:
                         negVertList.append(V1)
                 else:
                     # if they are on the same side of the plane
                         negVertList.append(V1)
                 else:
                     # if they are on the same side of the plane

-                    if d1*d0 > 0:
+                    if (d1 * d0) > 0:

                         #print "On the same half-space"
                         if d1 > 0:
                             #print "d1 on positive Halfspace"
                         #print "On the same half-space"
                         if d1 > 0:
                             #print "d1 on positive Halfspace"


@@ -665,7 +689,7 @@ class HSR:
                         e = Vector(V0), Vector(V1)
                         tri = Vector(Q[0]), Vector(Q[1]), Vector(Q[2])
 
                         e = Vector(V0), Vector(V1)
                         tri = Vector(Q[0]), Vector(Q[1]), Vector(Q[2])
 

-                        inters = Intersect(tri[0], tri[1], tri[2], e[1]-e[0], e[0], 0)
+                        inters = Intersect(tri[0], tri[1], tri[2], e[1] - e[0], e[0], 0)

                         if inters == None:
                             print "Split Break"
                             break
                         if inters == None:
                             print "Split Break"
                             break


@@ -683,11 +707,13 @@ class HSR:
                         else:
                             negVertList.append(V1)
 
                         else:
                             negVertList.append(V1)
 

-        
-        # uniq
-        posVertList = [ u for u in posVertList if u not in locals()['_[1]'] ]
-        negVertList = [ u for u in negVertList if u not in locals()['_[1]'] ]
+        # uniq for python > 2.4
+        #posVertList = [ u for u in posVertList if u not in locals()['_[1]'] ]
+        #negVertList = [ u for u in negVertList if u not in locals()['_[1]'] ]

 
 

+        # a more portable way
+        posVertList = uniq(posVertList)
+        negVertList = uniq(negVertList)

 
         # If vertex are all on the same half-space, return
         #if len(posVertList) < 3:
 
         # If vertex are all on the same half-space, return
         #if len(posVertList) < 3:


@@ -718,16 +744,15 @@ class HSR:
         if len(posVertList) or len(negVertList):
 
             #newfaces = [posVertList] + [negVertList]
         if len(posVertList) or len(negVertList):
 
             #newfaces = [posVertList] + [negVertList]

-            newfaces = ( [[ NMesh.Vert(v[0], v[1], v[2]) for v in posVertList]] +
-                    [[ NMesh.Vert(v[0], v[1], v[2]) for v in negVertList]] )
+            newfaces = ([[NMesh.Vert(v[0], v[1], v[2]) for v in posVertList]] +
+                    [[NMesh.Vert(v[0], v[1], v[2]) for v in negVertList]])

 
             for nf in newfaces:
 
             for nf in newfaces:

-                if nf and len(nf)>2:
+                if nf and len(nf) > 2:

                     outfaces += HSR.makeFaces(nf)
 
         return outfaces
 
                     outfaces += HSR.makeFaces(nf)
 
         return outfaces
 

-

     addNewFaces = staticmethod(addNewFaces)
 
 
     addNewFaces = staticmethod(addNewFaces)
 
 


@@ -740,7 +765,7 @@ class HSR:
 class MeshUtils:
 
     def buildEdgeFaceUsersCache(me):
 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
         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


@@ -750,29 +775,28 @@ class MeshUtils:
         '''
 
         def sorted_edge_indicies(ed):
         '''
 
         def sorted_edge_indicies(ed):

-            i1= ed.v1.index
-            i2= ed.v2.index
-            if i1>i2:
-                i1,i2= i2,i1
+            i1 = ed.v1.index
+            i2 = ed.v2.index
+            if i1 > i2:
+                i1, i2 = i2, i1

             return i1, i2
 
             return i1, i2
 

-       
-        face_edges_dict= dict([(sorted_edge_indicies(ed), (ed.index, [])) for ed in me.edges])
+        face_edges_dict = dict([(sorted_edge_indicies(ed), (ed.index, [])) for ed in me.edges])

         for f in me.faces:
         for f in me.faces:

-            fvi= [v.index for v in f.v]# face vert idx's
+            fvi = [v.index for v in f.v]  # face vert idx's

             for i in xrange(len(f)):
             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)
+                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():
         for ed_index, ed_faces in face_edges_dict.itervalues():

-            face_edges[ed_index]= ed_faces
-        
+            face_edges[ed_index] = ed_faces
+

         return face_edges
 
     def isMeshEdge(adjacent_faces):
         return face_edges
 
     def isMeshEdge(adjacent_faces):


@@ -827,8 +851,8 @@ class ShadingUtils:
     def toonShadingMapSetup():
         levels = config.polygons['TOON_LEVELS']
 
     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]
+        texels = 2 * levels - 1
+        tmp_shademap = [0.0] + [(i) / float(texels - 1) for i in xrange(1, texels - 1)] + [1.0]

 
         return tmp_shademap
 
 
         return tmp_shademap
 


@@ -840,13 +864,13 @@ class ShadingUtils:
             shademap = ShadingUtils.toonShadingMapSetup()
 
         v = 1.0
             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)
+        for i in xrange(0, len(shademap) - 1):
+            pivot = (shademap[i] + shademap[i + 1]) / 2.0
+            j = int(u > pivot)

 
 

-            v = shademap[i+j]
+            v = shademap[i + j]

 
 

-            if v < shademap[i+1]:
+            if v < shademap[i + 1]:

                 return v
 
         return v
                 return v
 
         return v


@@ -863,10 +887,10 @@ class ShadingUtils:
 
 class Projector:
     """Calculate the projection of an object given the camera.
 
 class Projector:
     """Calculate the projection of an object given the camera.

-    
+

     A projector is useful to so some per-object transformation to obtain the
     projection of an object given the camera.
     A projector is useful to so some per-object transformation to obtain the
     projection of an object given the camera.

-    
+

     The main method is #doProjection# see the method description for the
     parameter list.
     """
     The main method is #doProjection# see the method description for the
     parameter list.
     """


@@ -880,15 +904,14 @@ class Projector:
 
         camera = cameraObj.getData()
 
 
         camera = cameraObj.getData()
 

-        aspect = float(canvasRatio[0])/float(canvasRatio[1])
+        aspect = float(canvasRatio[0]) / float(canvasRatio[1])

         near = camera.clipStart
         far = camera.clipEnd
 
         scale = float(camera.scale)
 
         near = camera.clipStart
         far = camera.clipEnd
 
         scale = float(camera.scale)
 

-        fovy = atan(0.5/aspect/(camera.lens/32))
-        fovy = fovy * 360.0/pi
-
+        fovy = atan(0.5 / aspect / (camera.lens / 32))
+        fovy = fovy * 360.0 / pi

 
         if Blender.Get('version') < 243:
             camPersp = 0
 
         if Blender.Get('version') < 243:
             camPersp = 0


@@ -896,18 +919,17 @@ class Projector:
         else:
             camPersp = 'persp'
             camOrtho = 'ortho'
         else:
             camPersp = 'persp'
             camOrtho = 'ortho'

-            
+

         # What projection do we want?
         if camera.type == camPersp:
         # What projection do we want?
         if camera.type == camPersp:

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

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

-        

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

-        cam.transpose() 
-        
+        cam.transpose()
+

         mP = mP * cam
 
         self.projectionMatrix = mP
         mP = mP * cam
 
         self.projectionMatrix = mP


@@ -922,18 +944,18 @@ class Projector:
         Given a vertex calculate the projection using the current projection
         matrix.
         """
         Given a vertex calculate the projection using the current projection
         matrix.
         """

-        
+

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

-        
+

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

-            p[0] = p[0]/p[3]
-            p[1] = p[1]/p[3]
-            p[2] = p[2]/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


@@ -941,26 +963,25 @@ class Projector:
 
         return p
 
 
         return p
 

-

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

-    
+

     def _calcPerspectiveMatrix(self, fovy, aspect, near, far):
         """Return a perspective projection matrix.
         """
     def _calcPerspectiveMatrix(self, fovy, aspect, near, far):
         """Return a perspective projection matrix.
         """

-        
+

         top = near * tan(fovy * pi / 360.0)
         bottom = -top
         top = near * tan(fovy * pi / 360.0)
         bottom = -top

-        left = bottom*aspect
-        right= top*aspect
-        x = (2.0 * near) / (right-left)
-        y = (2.0 * near) / (top-bottom)
-        a = (right+left) / (right-left)
-        b = (top+bottom) / (top - bottom)
-        c = - ((far+near) / (far-near))
-        d = - ((2*far*near)/(far-near))
-        
+        left = bottom * aspect
+        right = top * aspect
+        x = (2.0 * near) / (right - left)
+        y = (2.0 * near) / (top - bottom)
+        a = (right + left) / (right - left)
+        b = (top + bottom) / (top - bottom)
+        c = - ((far + near) / (far - near))
+        d = - ((2 * far * near) / (far - near))
+

         m = Matrix(
                 [x,   0.0,    a,    0.0],
                 [0.0,   y,    b,    0.0],
         m = Matrix(
                 [x,   0.0,    a,    0.0],
                 [0.0,   y,    b,    0.0],


@@ -969,28 +990,28 @@ class Projector:
 
         return m
 
 
         return m
 

-    def _calcOrthoMatrix(self, fovy, aspect , near, far, scale):
+    def _calcOrthoMatrix(self, fovy, aspect, near, far, scale):

         """Return an orthogonal projection matrix.
         """
         """Return an orthogonal projection matrix.
         """

-        
+

         # The 11 in the formula was found emiprically
         top = near * tan(fovy * pi / 360.0) * (scale * 11)
         # The 11 in the formula was found emiprically
         top = near * tan(fovy * pi / 360.0) * (scale * 11)

-        bottom = -top 
+        bottom = -top

         left = bottom * aspect
         left = bottom * aspect

-        right= top * aspect
-        rl = right-left
-        tb = top-bottom
-        fn = near-far 
-        tx = -((right+left)/rl)
-        ty = -((top+bottom)/tb)
-        tz = ((far+near)/fn)
+        right = top * aspect
+        rl = right - left
+        tb = top - bottom
+        fn = near - far
+        tx = -((right + left) / rl)
+        ty = -((top + bottom) / tb)
+        tz = ((far + near) / fn)

 
         m = Matrix(
 
         m = Matrix(

-                [2.0/rl, 0.0,    0.0,     tx],
-                [0.0,    2.0/tb, 0.0,     ty],
-                [0.0,    0.0,    2.0/fn,  tz],
-                [0.0,    0.0,    0.0,    1.0])
-        
+                [2.0 / rl, 0.0,      0.0,       tx],
+                [0.0,      2.0 / tb, 0.0,       ty],
+                [0.0,      0.0,      2.0 / fn,  tz],
+                [0.0,      0.0,      0.0,      1.0])
+

         return m
 
 
         return m
 
 


@@ -1002,7 +1023,7 @@ class Projector:
 
 class Progress:
     """A model for a progress indicator.
 
 class Progress:
     """A model for a progress indicator.

-    
+

     Do the progress calculation calculation and
     the view independent stuff of a progress indicator.
     """
     Do the progress calculation calculation and
     the view independent stuff of a progress indicator.
     """


@@ -1042,7 +1063,7 @@ class Progress:
             return False
 
         self.completed += 1
             return False
 
         self.completed += 1

-        self.progress = ( float(self.completed) / float(self.steps) ) * 100
+        self.progress = (float(self.completed) / float(self.steps)) * 100

         self.progress = int(self.progress)
 
         return True
         self.progress = int(self.progress)
 
         return True


@@ -1114,17 +1135,17 @@ class ConsoleProgressIndicator(ProgressIndicator):
 
     def show(self, progress, name):
         ProgressIndicator.show(self, progress, name)
 
     def show(self, progress, name):
         ProgressIndicator.show(self, progress, name)

-        
+

         bar_length = 70
         bar_length = 70

-        bar_progress = int( (progress/100.0) * bar_length )
+        bar_progress = int((progress / 100.0) * bar_length)

         bar = ("=" * bar_progress).ljust(bar_length)
 
         bar = ("=" * bar_progress).ljust(bar_length)
 

-        self.swirl_count = (self.swirl_count+1)%len(self.swirl_chars)
+        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)
 
         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")
+        sys.stderr.write(progress_bar + "\r")

         if progress == 100:
             sys.stderr.write("\n")
 
         if progress == 100:
             sys.stderr.write("\n")
 


@@ -1145,21 +1166,19 @@ class GraphicalProgressIndicator(ProgressIndicator):
     def show(self, progress, name):
         ProgressIndicator.show(self, progress)
 
     def show(self, progress, name):
         ProgressIndicator.show(self, progress)
 

-        self.swirl_count = (self.swirl_count+1)%len(self.swirl_chars)
+        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
         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)
+        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)
 
 
         if progress == 100:
             Window.DrawProgressBar(1, progress_text)
             Window.WaitCursor(0)
 

-
-

 # ---------------------------------------------------------------------
 #
 ## 2D Object representation class
 # ---------------------------------------------------------------------
 #
 ## 2D Object representation class


@@ -1192,14 +1211,20 @@ class VectorWriter:
         - printCanvas(self, scene,
             doPrintPolygons=True, doPrintEdges=False, showHiddenEdges=False):
     """
         - printCanvas(self, scene,
             doPrintPolygons=True, doPrintEdges=False, showHiddenEdges=False):
     """

-    
+

     def __init__(self, fileName):
         """Set the output file name and other properties"""
 
     def __init__(self, fileName):
         """Set the output file name and other properties"""
 

+        try:
+            config.writer
+        except:
+            config.writer = dict()
+            config.writer['SETTING'] = True
+

         self.outputFileName = fileName
         self.outputFileName = fileName

-        
+

         context = Scene.GetCurrent().getRenderingContext()
         context = Scene.GetCurrent().getRenderingContext()

-        self.canvasSize = ( context.imageSizeX(), context.imageSizeY() )
+        self.canvasSize = (context.imageSizeX(), context.imageSizeY())

 
         self.fps = context.fps
 
 
         self.fps = context.fps
 


@@ -1207,11 +1232,10 @@ class VectorWriter:
         self.endFrame = 1
         self.animation = False
 
         self.endFrame = 1
         self.animation = False
 

-

     ##
     # Public Methods
     #
     ##
     # Public Methods
     #

-    
+

     def open(self, startFrame=1, endFrame=1):
         if startFrame != endFrame:
             self.startFrame = startFrame
     def open(self, startFrame=1, endFrame=1):
         if startFrame != endFrame:
             self.startFrame = startFrame


@@ -1230,7 +1254,7 @@ class VectorWriter:
         """This is the interface for the needed printing routine.
         """
         return
         """This is the interface for the needed printing routine.
         """
         return

-        
+

 
 ## SVG Writer
 
 
 ## SVG Writer
 


@@ -1245,7 +1269,6 @@ class SVGVectorWriter(VectorWriter):
 
         self.file = None
 
 
         self.file = None
 

-

     ##
     # Public Methods
     #
     ##
     # Public Methods
     #


@@ -1270,13 +1293,12 @@ class SVGVectorWriter(VectorWriter):
         # remember to call the close method of the parent as last
         VectorWriter.close(self)
 
         # remember to call the close method of the parent as last
         VectorWriter.close(self)
 

-        

     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
             showHiddenEdges=False):
         """Convert the scene representation to SVG.
         """
 
     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
             showHiddenEdges=False):
         """Convert the scene representation to SVG.
         """
 

-        Objects = scene.getChildren()
+        Objects = scene.objects

 
         context = scene.getRenderingContext()
         framenumber = context.currentFrame()
 
         context = scene.getRenderingContext()
         framenumber = context.currentFrame()


@@ -1285,15 +1307,14 @@ class SVGVectorWriter(VectorWriter):
             framestyle = "display:none"
         else:
             framestyle = "display:block"
             framestyle = "display:none"
         else:
             framestyle = "display:block"

-        
+

         # Assign an id to this group so we can set properties on it using DOM
         self.file.write("<g id=\"frame%d\" style=\"%s\">\n" %
         # Assign an id to this group so we can set properties on it using DOM
         self.file.write("<g id=\"frame%d\" style=\"%s\">\n" %

-                (framenumber, framestyle) )
-
+                (framenumber, framestyle))

 
         for obj in Objects:
 
 
         for obj in Objects:
 

-            if(obj.getType() != 'Mesh'):
+            if obj.getType() != 'Mesh':

                 continue
 
             self.file.write("<g id=\"%s\">\n" % obj.getName())
                 continue
 
             self.file.write("<g id=\"%s\">\n" % obj.getName())


@@ -1305,35 +1326,34 @@ class SVGVectorWriter(VectorWriter):
 
             if doPrintEdges:
                 self._printEdges(mesh, showHiddenEdges)
 
             if doPrintEdges:
                 self._printEdges(mesh, showHiddenEdges)

-            
+

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

-    
-    ##  
+    ##

     # Private Methods
     #
     # Private Methods
     #

-    
+

     def _calcCanvasCoord(self, v):
         """Convert vertex in scene coordinates to canvas coordinates.
         """
 
         pt = Vector([0, 0, 0])
     def _calcCanvasCoord(self, v):
         """Convert vertex in scene coordinates to canvas coordinates.
         """
 
         pt = Vector([0, 0, 0])

-        
-        mW = float(self.canvasSize[0])/2.0
-        mH = float(self.canvasSize[1])/2.0
+
+        mW = float(self.canvasSize[0]) / 2.0
+        mH = float(self.canvasSize[1]) / 2.0

 
         # rescale to canvas size
 
         # rescale to canvas size

-        pt[0] = v.co[0]*mW + mW
-        pt[1] = v.co[1]*mH + mH
+        pt[0] = v.co[0] * mW + mW
+        pt[1] = v.co[1] * mH + mH

         pt[2] = v.co[2]
         pt[2] = v.co[2]

-         
+

         # For now we want (0,0) in the top-left corner of the canvas.
         # Mirror and translate along y
         pt[1] *= -1
         pt[1] += self.canvasSize[1]
         # For now we want (0,0) in the top-left corner of the canvas.
         # Mirror and translate along y
         pt[1] *= -1
         pt[1] += self.canvasSize[1]

-        
+

         return pt
 
     def _printHeader(self):
         return pt
 
     def _printHeader(self):


@@ -1348,7 +1368,7 @@ class SVGVectorWriter(VectorWriter):
                 self.canvasSize)
 
         if self.animation:
                 self.canvasSize)
 
         if self.animation:

-            delay = 1000/self.fps
+            delay = 1000 / self.fps

 
             self.file.write("""\n<script type="text/javascript"><![CDATA[
             globalStartFrame=%d;
 
             self.file.write("""\n<script type="text/javascript"><![CDATA[
             globalStartFrame=%d;


@@ -1356,7 +1376,7 @@ class SVGVectorWriter(VectorWriter):
 
             timerID = setInterval("NextFrame()", %d);
             globalFrameCounter=%d;
 
             timerID = setInterval("NextFrame()", %d);
             globalFrameCounter=%d;

-            \n""" % (self.startFrame, self.endFrame, delay, self.startFrame) )
+            \n""" % (self.startFrame, self.endFrame, delay, self.startFrame))

 
             self.file.write("""\n
             function NextFrame()
 
             self.file.write("""\n
             function NextFrame()


@@ -1385,13 +1405,13 @@ class SVGVectorWriter(VectorWriter):
             }
             \n]]></script>\n
             \n""")
             }
             \n]]></script>\n
             \n""")

-                
+

     def _printFooter(self):
         """Print the SVG footer."""
 
         self.file.write("\n</svg>\n")
 
     def _printFooter(self):
         """Print the SVG footer."""
 
         self.file.write("\n</svg>\n")
 

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

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


@@ -1402,7 +1422,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("<path d=\"")
 
 
             self.file.write("<path d=\"")
 


@@ -1413,11 +1433,11 @@ class SVGVectorWriter(VectorWriter):
             for v in face.v[1:]:
                 p = self._calcCanvasCoord(v)
                 self.file.write("%g,%g " % (p[0], p[1]))
             for v in face.v[1:]:
                 p = self._calcCanvasCoord(v)
                 self.file.write("%g,%g " % (p[0], p[1]))

-            
+

             # get rid of the last blank space, just cosmetics here.
             # get rid of the last blank space, just cosmetics here.

-            self.file.seek(-1, 1) 
+            self.file.seek(-1, 1)

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

-            
+

             # take as face color the first vertex color
             if face.col:
                 fcol = face.col[0]
             # take as face color the first vertex color
             if face.col:
                 fcol = face.col[0]


@@ -1431,7 +1451,7 @@ class SVGVectorWriter(VectorWriter):
             # Handle transparent polygons
             opacity_string = ""
             if color[3] != 255:
             # Handle transparent polygons
             opacity_string = ""
             if color[3] != 255:

-                opacity = float(color[3])/255.0
+                opacity = float(color[3]) / 255.0

                 opacity_string = " fill-opacity: %g; stroke-opacity: %g; opacity: 1;" % (opacity, opacity)
                 #opacity_string = "opacity: %g;" % (opacity)
 
                 opacity_string = " fill-opacity: %g; stroke-opacity: %g; opacity: 1;" % (opacity, opacity)
                 #opacity_string = "opacity: %g;" % (opacity)
 


@@ -1460,13 +1480,13 @@ class SVGVectorWriter(VectorWriter):
 
         stroke_width = config.edges['WIDTH']
         stroke_col = config.edges['COLOR']
 
         stroke_width = config.edges['WIDTH']
         stroke_col = config.edges['COLOR']

-        
+

         self.file.write("<g>\n")
 
         for e in mesh.edges:
         self.file.write("<g>\n")
 
         for e in mesh.edges:

-            
+

             hidden_stroke_style = ""
             hidden_stroke_style = ""

-            
+

             if e.sel == 0:
                 if showHiddenEdges == False:
                     continue
             if e.sel == 0:
                 if showHiddenEdges == False:
                     continue


@@ -1475,11 +1495,11 @@ class SVGVectorWriter(VectorWriter):
 
             p1 = self._calcCanvasCoord(e.v1)
             p2 = self._calcCanvasCoord(e.v2)
 
             p1 = self._calcCanvasCoord(e.v1)
             p2 = self._calcCanvasCoord(e.v2)

-            
+

             self.file.write("<line x1=\"%g\" y1=\"%g\" x2=\"%g\" y2=\"%g\"\n"
             self.file.write("<line x1=\"%g\" y1=\"%g\" x2=\"%g\" y2=\"%g\"\n"

-                    % ( p1[0], p1[1], p2[0], p2[1] ) )
-            self.file.write(" style=\"stroke:rgb("+str(stroke_col[0])+","+str(stroke_col[1])+","+str(stroke_col[2])+");")
-            self.file.write(" stroke-width:"+str(stroke_width)+";\n")
+                    % (p1[0], p1[1], p2[0], p2[1]))
+            self.file.write(" style=\"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-linecap:round;stroke-linejoin:round")
             self.file.write(hidden_stroke_style)
             self.file.write("\"/>\n")
             self.file.write(" stroke-linecap:round;stroke-linejoin:round")
             self.file.write(hidden_stroke_style)
             self.file.write("\"/>\n")


@@ -1495,6 +1515,7 @@ try:
 except:
     SWFSupported = False
 
 except:
     SWFSupported = False
 

+

 class SWFVectorWriter(VectorWriter):
     """A concrete class for writing SWF output.
     """
 class SWFVectorWriter(VectorWriter):
     """A concrete class for writing SWF output.
     """


@@ -1507,7 +1528,6 @@ class SWFVectorWriter(VectorWriter):
         self.movie = None
         self.sprite = None
 
         self.movie = None
         self.sprite = None
 

-

     ##
     # Public Methods
     #
     ##
     # Public Methods
     #


@@ -1538,7 +1558,7 @@ class SWFVectorWriter(VectorWriter):
         context = scene.getRenderingContext()
         framenumber = context.currentFrame()
 
         context = scene.getRenderingContext()
         framenumber = context.currentFrame()
 

-        Objects = scene.getChildren()
+        Objects = scene.objects

 
         if self.sprite:
             self.movie.remove(self.sprite)
 
         if self.sprite:
             self.movie.remove(self.sprite)


@@ -1557,7 +1577,7 @@ class SWFVectorWriter(VectorWriter):
 
             if doPrintEdges:
                 self._printEdges(mesh, sprite, showHiddenEdges)
 
             if doPrintEdges:
                 self._printEdges(mesh, sprite, showHiddenEdges)

-            
+

         sprite.nextFrame()
         i = self.movie.add(sprite)
         # Remove the instance the next time
         sprite.nextFrame()
         i = self.movie.add(sprite)
         # Remove the instance the next time


@@ -1565,33 +1585,32 @@ class SWFVectorWriter(VectorWriter):
         if self.animation:
             self.movie.nextFrame()
 
         if self.animation:
             self.movie.nextFrame()
 

-    
-    ##  
+    ##

     # Private Methods
     #
     # Private Methods
     #

-    
+

     def _calcCanvasCoord(self, v):
         """Convert vertex in scene coordinates to canvas coordinates.
         """
 
         pt = Vector([0, 0, 0])
     def _calcCanvasCoord(self, v):
         """Convert vertex in scene coordinates to canvas coordinates.
         """
 
         pt = Vector([0, 0, 0])

-        
-        mW = float(self.canvasSize[0])/2.0
-        mH = float(self.canvasSize[1])/2.0
+
+        mW = float(self.canvasSize[0]) / 2.0
+        mH = float(self.canvasSize[1]) / 2.0

 
         # rescale to canvas size
 
         # rescale to canvas size

-        pt[0] = v.co[0]*mW + mW
-        pt[1] = v.co[1]*mH + mH
+        pt[0] = v.co[0] * mW + mW
+        pt[1] = v.co[1] * mH + mH

         pt[2] = v.co[2]
         pt[2] = v.co[2]

-         
+

         # For now we want (0,0) in the top-left corner of the canvas.
         # Mirror and translate along y
         pt[1] *= -1
         pt[1] += self.canvasSize[1]
         # For now we want (0,0) in the top-left corner of the canvas.
         # Mirror and translate along y
         pt[1] *= -1
         pt[1] += self.canvasSize[1]

-        
+

         return pt
         return pt

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

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


@@ -1600,7 +1619,7 @@ class SWFVectorWriter(VectorWriter):
 
         for face in mesh.faces:
             if not face.sel:
 
         for face in mesh.faces:
             if not face.sel:

-               continue
+                continue

 
             if face.col:
                 fcol = face.col[0]
 
             if face.col:
                 fcol = face.col[0]


@@ -1619,14 +1638,13 @@ class SWFVectorWriter(VectorWriter):
             for v in face.verts[1:]:
                 p = self._calcCanvasCoord(v)
                 s.drawLineTo(p[0], p[1])
             for v in face.verts[1:]:
                 p = self._calcCanvasCoord(v)
                 s.drawLineTo(p[0], p[1])

-            
+

             # Closing the shape
             s.drawLineTo(p0[0], p0[1])
 
             s.end()
             sprite.add(s)
 
             # Closing the shape
             s.drawLineTo(p0[0], p0[1])
 
             s.end()
             sprite.add(s)
 

-

     def _printEdges(self, mesh, sprite, showHiddenEdges=False):
         """Print the wireframe using mesh edges.
         """
     def _printEdges(self, mesh, sprite, showHiddenEdges=False):
         """Print the wireframe using mesh edges.
         """


@@ -1641,14 +1659,14 @@ class SWFVectorWriter(VectorWriter):
             # Next, we set the line width and color for our shape.
             s.setLine(stroke_width, stroke_col[0], stroke_col[1], stroke_col[2],
             255)
             # Next, we set the line width and color for our shape.
             s.setLine(stroke_width, stroke_col[0], stroke_col[1], stroke_col[2],
             255)

-            
+

             if e.sel == 0:
                 if showHiddenEdges == False:
                     continue
                 else:
                     # SWF does not support dashed lines natively, so -for now-
                     # draw hidden lines thinner and half-trasparent
             if e.sel == 0:
                 if showHiddenEdges == False:
                     continue
                 else:
                     # SWF does not support dashed lines natively, so -for now-
                     # draw hidden lines thinner and half-trasparent

-                    s.setLine(stroke_width/2, stroke_col[0], stroke_col[1],
+                    s.setLine(stroke_width / 2, stroke_col[0], stroke_col[1],

                             stroke_col[2], 128)
 
             p1 = self._calcCanvasCoord(e.v1)
                             stroke_col[2], 128)
 
             p1 = self._calcCanvasCoord(e.v1)


@@ -1659,7 +1677,7 @@ class SWFVectorWriter(VectorWriter):
 
         s.end()
         sprite.add(s)
 
         s.end()
         sprite.add(s)

-            
+

 
 ## PDF Writer
 
 
 ## PDF Writer
 


@@ -1669,6 +1687,7 @@ try:
 except:
     PDFSupported = False
 
 except:
     PDFSupported = False
 

+

 class PDFVectorWriter(VectorWriter):
     """A concrete class for writing PDF output.
     """
 class PDFVectorWriter(VectorWriter):
     """A concrete class for writing PDF output.
     """


@@ -1680,7 +1699,6 @@ class PDFVectorWriter(VectorWriter):
 
         self.canvas = None
 
 
         self.canvas = None
 

-

     ##
     # Public Methods
     #
     ##
     # Public Methods
     #


@@ -1707,7 +1725,7 @@ class PDFVectorWriter(VectorWriter):
         context = scene.getRenderingContext()
         framenumber = context.currentFrame()
 
         context = scene.getRenderingContext()
         framenumber = context.currentFrame()
 

-        Objects = scene.getChildren()
+        Objects = scene.objects

 
         for obj in Objects:
 
 
         for obj in Objects:
 


@@ -1721,35 +1739,35 @@ class PDFVectorWriter(VectorWriter):
 
             if doPrintEdges:
                 self._printEdges(mesh, showHiddenEdges)
 
             if doPrintEdges:
                 self._printEdges(mesh, showHiddenEdges)

-            
+

         self.canvas.showPage()
         self.canvas.showPage()

-    
-    ##  
+
+    ##

     # Private Methods
     #
     # Private Methods
     #

-    
+

     def _calcCanvasCoord(self, v):
         """Convert vertex in scene coordinates to canvas coordinates.
         """
 
         pt = Vector([0, 0, 0])
     def _calcCanvasCoord(self, v):
         """Convert vertex in scene coordinates to canvas coordinates.
         """
 
         pt = Vector([0, 0, 0])

-        
-        mW = float(self.canvasSize[0])/2.0
-        mH = float(self.canvasSize[1])/2.0
+
+        mW = float(self.canvasSize[0]) / 2.0
+        mH = float(self.canvasSize[1]) / 2.0

 
         # rescale to canvas size
 
         # rescale to canvas size

-        pt[0] = v.co[0]*mW + mW
-        pt[1] = v.co[1]*mH + mH
+        pt[0] = v.co[0] * mW + mW
+        pt[1] = v.co[1] * mH + mH

         pt[2] = v.co[2]
         pt[2] = v.co[2]

-         
+

         # For now we want (0,0) in the top-left corner of the canvas.
         # Mirror and translate along y
         pt[1] *= -1
         pt[1] += self.canvasSize[1]
         # For now we want (0,0) in the top-left corner of the canvas.
         # Mirror and translate along y
         pt[1] *= -1
         pt[1] += self.canvasSize[1]

-        
+

         return pt
         return pt

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

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


@@ -1758,12 +1776,12 @@ class PDFVectorWriter(VectorWriter):
 
         for face in mesh.faces:
             if not face.sel:
 
         for face in mesh.faces:
             if not face.sel:

-               continue
+                continue

 
             if face.col:
                 fcol = face.col[0]
 
             if face.col:
                 fcol = face.col[0]

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

             else:
                 color = [1, 1, 1, 1]
 
             else:
                 color = [1, 1, 1, 1]
 


@@ -1780,7 +1798,7 @@ class PDFVectorWriter(VectorWriter):
             for v in face.verts[1:]:
                 p = self._calcCanvasCoord(v)
                 path.lineTo(p[0], p[1])
             for v in face.verts[1:]:
                 p = self._calcCanvasCoord(v)
                 path.lineTo(p[0], p[1])

-            
+

             # Closing the shape
             path.close()
 
             # Closing the shape
             path.close()
 


@@ -1792,12 +1810,12 @@ class PDFVectorWriter(VectorWriter):
 
         stroke_width = config.edges['WIDTH']
         stroke_col = config.edges['COLOR']
 
         stroke_width = config.edges['WIDTH']
         stroke_col = config.edges['COLOR']

-       
+

         self.canvas.setLineCap(1)
         self.canvas.setLineJoin(1)
         self.canvas.setLineWidth(stroke_width)
         self.canvas.setLineCap(1)
         self.canvas.setLineJoin(1)
         self.canvas.setLineWidth(stroke_width)

-        self.canvas.setStrokeColorRGB(stroke_col[0]/255.0, stroke_col[1]/255.0,
-            stroke_col[2]/255)
+        self.canvas.setStrokeColorRGB(stroke_col[0] / 255.0, stroke_col[1] / 255.0,
+            stroke_col[2] / 255)

 
         for e in mesh.edges:
 
 
         for e in mesh.edges:
 


@@ -1809,15 +1827,13 @@ class PDFVectorWriter(VectorWriter):
                 else:
                     # PDF does not support dashed lines natively, so -for now-
                     # draw hidden lines thinner
                 else:
                     # PDF does not support dashed lines natively, so -for now-
                     # draw hidden lines thinner

-                    self.canvas.setLineWidth(stroke_width/2.0)
+                    self.canvas.setLineWidth(stroke_width / 2.0)

 
             p1 = self._calcCanvasCoord(e.v1)
             p2 = self._calcCanvasCoord(e.v2)
 
             self.canvas.line(p1[0], p1[1], p2[0], p2[1])
 
 
             p1 = self._calcCanvasCoord(e.v1)
             p2 = self._calcCanvasCoord(e.v2)
 
             self.canvas.line(p1[0], p1[1], p2[0], p2[1])
 

-
-

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


@@ -1845,7 +1861,7 @@ if PDFSupported:
 
 class Renderer:
     """Render a scene viewed from the active camera.
 
 class Renderer:
     """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.
 


@@ -1861,31 +1877,19 @@ class Renderer:
 
         # Render the current Scene, this should be a READ-ONLY property
         self._SCENE = Scene.GetCurrent()
 
         # Render the current Scene, this should be a READ-ONLY property
         self._SCENE = Scene.GetCurrent()

-        
+

         # Use the aspect ratio of the scene rendering context
         context = self._SCENE.getRenderingContext()
 
         # Use the aspect ratio of the scene rendering context
         context = self._SCENE.getRenderingContext()
 

-        aspect_ratio = float(context.imageSizeX())/float(context.imageSizeY())
-        self.canvasRatio = (float(context.aspectRatioX())*aspect_ratio,
+        aspect_ratio = float(context.imageSizeX()) / float(context.imageSizeY())
+        self.canvasRatio = (float(context.aspectRatioX()) * aspect_ratio,

                             float(context.aspectRatioY())
                             )
 
                             float(context.aspectRatioY())
                             )
 

-        # Render from the currently active camera 
-        #self.cameraObj = self._SCENE.getCurrentCamera()
-
-        # 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')
-            lobj.loc = self.cameraObj.loc
-            lobj.link(l) 
-            self.lights.append(lobj)
+        # Render from the currently active camera
+        #self.cameraObj = self._SCENE.objects.camera

 
 

+        self.lights = []

 
     ##
     # Public Methods
 
     ##
     # Public Methods


@@ -1893,13 +1897,13 @@ class Renderer:
 
     def doRendering(self, outputWriter, animation=False):
         """Render picture or animation and write it out.
 
     def doRendering(self, outputWriter, animation=False):
         """Render picture or animation and write it out.

-        
+

         The parameters are:
             - 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.
         """
         The parameters are:
             - 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.
         """

-        
+

         context = self._SCENE.getRenderingContext()
         origCurrentFrame = context.currentFrame()
 
         context = self._SCENE.getRenderingContext()
         origCurrentFrame = context.currentFrame()
 


@@ -1912,16 +1916,16 @@ class Renderer:
             startFrame = context.startFrame()
             endFrame = context.endFrame()
             outputWriter.open(startFrame, endFrame)
             startFrame = context.startFrame()
             endFrame = context.endFrame()
             outputWriter.open(startFrame, endFrame)

-        
+

         # Do the rendering process frame by frame
         # Do the rendering process frame by frame

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

             print "\n\nFrame: %d" % f
 
             # FIXME To get the correct camera position we have to use +1 here.
             # Is there a bug somewhere in the Scene module?
             print "\n\nFrame: %d" % f
 
             # FIXME To get the correct camera position we have to use +1 here.
             # Is there a bug somewhere in the Scene module?

-            context.currentFrame(f+1)
-            self.cameraObj = self._SCENE.getCurrentCamera()
+            context.currentFrame(f + 1)
+            self.cameraObj = self._SCENE.objects.camera

 
             # Use some temporary workspace, a full copy of the scene
             inputScene = self._SCENE.copy(2)
 
             # Use some temporary workspace, a full copy of the scene
             inputScene = self._SCENE.copy(2)


@@ -1930,7 +1934,6 @@ class Renderer:
             ctx = inputScene.getRenderingContext()
             ctx.currentFrame(f)
 
             ctx = inputScene.getRenderingContext()
             ctx.currentFrame(f)
 

-

             # Get a projector for this camera.
             # NOTE: the projector wants object in world coordinates,
             # so we should remember to apply modelview transformations
             # Get a projector for this camera.
             # NOTE: the projector wants object in world coordinates,
             # so we should remember to apply modelview transformations


@@ -1939,40 +1942,43 @@ class Renderer:
 
             try:
                 renderedScene = self.doRenderScene(inputScene)
 
             try:
                 renderedScene = self.doRenderScene(inputScene)

-            except :
+            except:

                 print "There was an error! Aborting."
                 import traceback
                 print traceback.print_exc()
 
                 self._SCENE.makeCurrent()
                 print "There was an error! Aborting."
                 import traceback
                 print traceback.print_exc()
 
                 self._SCENE.makeCurrent()

-                Scene.unlink(inputScene)
+                Scene.Unlink(inputScene)

                 del inputScene
                 return
 
             outputWriter.printCanvas(renderedScene,
                 del inputScene
                 return
 
             outputWriter.printCanvas(renderedScene,

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

             # delete the rendered scene
             self._SCENE.makeCurrent()
             # delete the rendered scene
             self._SCENE.makeCurrent()

-            Scene.unlink(renderedScene)
+            Scene.Unlink(renderedScene)

             del renderedScene
 
         outputWriter.close()
         print "Done!"
         context.currentFrame(origCurrentFrame)
 
             del renderedScene
 
         outputWriter.close()
         print "Done!"
         context.currentFrame(origCurrentFrame)
 

-

     def doRenderScene(self, workScene):
         """Control the rendering process.
     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.
         """
         Here we control the entire rendering process invoking the operation
         needed to transform and project the 3D scene in two dimensions.
         """

-        
+

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

+        self._filterHiddenObjects(workScene)
+
+        self._buildLightSetup(workScene)
+

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


@@ -1981,12 +1987,13 @@ class Renderer:
             self._joinMeshObjectsInScene(workScene)
 
         self._doSceneDepthSorting(workScene)
             self._joinMeshObjectsInScene(workScene)
 
         self._doSceneDepthSorting(workScene)

-        
+

         # Per object activities
 
         # Per object activities
 

-        Objects = workScene.getChildren()
+        Objects = workScene.objects
+

         print "Total Objects: %d" % len(Objects)
         print "Total Objects: %d" % len(Objects)

-        for i,obj in enumerate(Objects):
+        for i, obj in enumerate(Objects):

             print "\n\n-------"
             print "Rendering Object: %d" % i
 
             print "\n\n-------"
             print "Rendering Object: %d" % i
 


@@ -2002,12 +2009,11 @@ class Renderer:
 
             self._doBackFaceCulling(mesh)
 
 
             self._doBackFaceCulling(mesh)
 

-

             # When doing HSR with NEWELL we may want to flip all normals
             # toward the viewer
             if config.polygons['HSR'] == "NEWELL":
                 for f in mesh.faces:
             # When doing HSR with NEWELL we may want to flip all normals
             # toward the viewer
             if config.polygons['HSR'] == "NEWELL":
                 for f in mesh.faces:

-                    f.sel = 1-f.sel
+                    f.sel = 1 - f.sel

                 mesh.flipNormals()
                 for f in mesh.faces:
                     f.sel = 1
                 mesh.flipNormals()
                 for f in mesh.faces:
                     f.sel = 1


@@ -2029,7 +2035,6 @@ class Renderer:
 
         return workScene
 
 
         return workScene
 

-

     ##
     # Private Methods
     #
     ##
     # Private Methods
     #


@@ -2046,12 +2051,11 @@ class Renderer:
         """
         return Vector(self.cameraObj.matrix[2]).resize3D()
 
         """
         return Vector(self.cameraObj.matrix[2]).resize3D()
 

-

     # Faces methods
 
     def _isFaceVisible(self, face):
         """Determine if a face of an object is visible from the current camera.
     # Faces methods
 
     def _isFaceVisible(self, face):
         """Determine if a face of an object is visible from the current camera.

-        
+

         The view vector is calculated from the camera location and one of the
         vertices of the face (expressed in World coordinates, after applying
         modelview transformations).
         The view vector is calculated from the camera location and one of the
         vertices of the face (expressed in World coordinates, after applying
         modelview transformations).


@@ -2082,21 +2086,48 @@ class Renderer:
         # 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:
         # 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:

-            vv = max( [ ((camPos - Vector(v.co)).length, (camPos - Vector(v.co))) for v in face] )
+            vv = max([((camPos - Vector(v.co)).length, (camPos - Vector(v.co))) for v in face])

             view_vect = vv[1]
 
             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

-        
+

         if d > 0:
             return True
         else:
             return False
 
         if d > 0:
             return True
         else:
             return False
 

-

     # Scene methods
 
     # Scene methods
 

+    def _filterHiddenObjects(self, scene):
+        """Discard object that are on hidden layers in the scene.
+        """
+
+        Objects = scene.objects
+
+        visible_obj_list = [obj for obj in Objects if
+                set(obj.layers).intersection(set(scene.getLayers()))]
+
+        for o in Objects:
+            if o not in visible_obj_list:
+                scene.objects.unlink(o)
+
+        scene.update()
+
+    def _buildLightSetup(self, scene):
+        # Get the list of lighting sources
+        obj_lst = scene.objects
+        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')
+            lobj.loc = self.cameraObj.loc
+            lobj.link(l)
+            self.lights.append(lobj)
+

     def _doSceneClipping(self, scene):
         """Clip whole objects against the View Frustum.
 
     def _doSceneClipping(self, scene):
         """Clip whole objects against the View Frustum.
 


@@ -2107,32 +2138,34 @@ class Renderer:
         view_vect = self._cameraViewVector()
 
         near = self.cameraObj.data.clipStart
         view_vect = self._cameraViewVector()
 
         near = self.cameraObj.data.clipStart

-        far  = self.cameraObj.data.clipEnd
+        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

 
 

-        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.objects

 
 

-        Objects = scene.getChildren()

         for o in Objects:
         for o in Objects:

-            if o.getType() != 'Mesh': continue;
+            if o.getType() != 'Mesh':
+                continue

 
             """
             obj_vect = Vector(cam_pos) - self._getObjPosition(o)
 
             d = obj_vect*view_vect
             theta = AngleBetweenVecs(obj_vect, view_vect)
 
             """
             obj_vect = Vector(cam_pos) - 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):
             # if the object is outside the view frustum, clip it away
             if (d < near) or (d > far) or (theta > fovy):

-                scene.unlink(o)
+                scene.objects.unlink(o)

             """
 
             # Use the object bounding box
             # (whose points are already in WorldSpace Coordinate)
 
             bb = o.getBoundBox()
             """
 
             # Use the object bounding box
             # (whose points are already in WorldSpace Coordinate)
 
             bb = o.getBoundBox()

-            
+

             points_outside = 0
             for p in bb:
                 p_vect = Vector(cam_pos) - Vector(p)
             points_outside = 0
             for p in bb:
                 p_vect = Vector(cam_pos) - Vector(p)


@@ -2147,9 +2180,7 @@ class Renderer:
             # If the bb is all outside the view frustum we clip the whole
             # object away
             if points_outside == len(bb):
             # If the bb is all outside the view frustum we clip the whole
             # object away
             if points_outside == len(bb):

-                scene.unlink(o)
-
-
+                scene.objects.unlink(o)

 
     def _doConvertGeometricObjsToMesh(self, scene):
         """Convert all "geometric" objects to mesh ones.
 
     def _doConvertGeometricObjsToMesh(self, scene):
         """Convert all "geometric" objects to mesh ones.


@@ -2157,28 +2188,31 @@ class Renderer:
         geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text']
         #geometricObjTypes = ['Mesh', 'Surf', 'Curve']
 
         geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text']
         #geometricObjTypes = ['Mesh', 'Surf', 'Curve']
 

-        Objects = scene.getChildren()
-        objList = [ o for o in Objects if o.getType() in geometricObjTypes ]
+        Objects = scene.objects
+
+        objList = [o for o in Objects if o.getType() in geometricObjTypes]

         for obj in objList:
             old_obj = obj
             obj = self._convertToRawMeshObj(obj)
         for obj in objList:
             old_obj = obj
             obj = self._convertToRawMeshObj(obj)

-            scene.link(obj)
-            scene.unlink(old_obj)
-
+            scene.objects.link(obj)
+            scene.objects.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)
 
             # 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;
+
+                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()
 
                 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.
 


@@ -2197,26 +2231,26 @@ class Renderer:
         # nearest to the camera should be drawn as last.
         by_nearest_bbox_point = (lambda o1, o2:
                 (o1.getType() == 'Mesh' and o2.getType() == 'Mesh') and
         # nearest to the camera should be drawn as last.
         by_nearest_bbox_point = (lambda o1, o2:
                 (o1.getType() == 'Mesh' and o2.getType() == 'Mesh') and

-                cmp( min( [(Vector(p) - Vector(c)).length for p in o1.getBoundBox()] ),
-                     min( [(Vector(p) - Vector(c)).length for p in o2.getBoundBox()] )
+                cmp(min([(Vector(p) - Vector(c)).length for p in o1.getBoundBox()]),
+                    min([(Vector(p) - Vector(c)).length for p in o2.getBoundBox()])

                 )
             )
 
                 )
             )
 

-        
-        Objects = scene.getChildren()
+        Objects = list(scene.objects)
+

         #Objects.sort(by_obj_center_pos)
         Objects.sort(by_nearest_bbox_point)
         #Objects.sort(by_obj_center_pos)
         Objects.sort(by_nearest_bbox_point)

-        
+

         # update the scene
         for o in Objects:
         # update the scene
         for o in Objects:

-            scene.unlink(o)
-            scene.link(o)
+            scene.objects.unlink(o)
+            scene.objects.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.
         """
 

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

 
         # FIXME: Object.join() do not work if the list contains 1 object
         if len(oList) == 1:
 
         # FIXME: Object.join() do not work if the list contains 1 object
         if len(oList) == 1:


@@ -2226,32 +2260,31 @@ class Renderer:
         bigObj = Object.New('Mesh', 'BigOne')
         bigObj.link(mesh)
 
         bigObj = Object.New('Mesh', 'BigOne')
         bigObj.link(mesh)
 

-        scene.link(bigObj)
+        scene.objects.link(bigObj)

 
         try:
             bigObj.join(oList)
         except RuntimeError:
             print "\nWarning! - Can't Join Objects\n"
 
         try:
             bigObj.join(oList)
         except RuntimeError:
             print "\nWarning! - Can't Join Objects\n"

-            scene.unlink(bigObj)
+            scene.objects.unlink(bigObj)

             return
         except TypeError:
             print "Objects Type error?"
             return
         except TypeError:
             print "Objects Type error?"

-        
+

         for o in oList:
         for o in oList:

-            scene.unlink(o)
+            scene.objects.unlink(o)

 
         scene.update()
 
 
         scene.update()
 

- 

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

-        me = Mesh.New('RawMesh_'+object.name)
+        me = Mesh.New('RawMesh_' + object.name)

         me.getFromObject(object.name)
 
         me.getFromObject(object.name)
 

-        newObject = Object.New('Mesh', 'RawMesh_'+object.name)
+        newObject = Object.New('Mesh', 'RawMesh_' + object.name)

         newObject.link(me)
 
         # If the object has no materials set a default material
         newObject.link(me)
 
         # If the object has no materials set a default material


@@ -2278,16 +2311,16 @@ class Renderer:
 
     def _doBackFaceCulling(self, mesh):
         """Simple Backface Culling routine.
 
     def _doBackFaceCulling(self, mesh):
         """Simple Backface Culling routine.

-        
+

         At this level we simply do a visibility test face by face and then
         select the vertices belonging to visible faces.
         """
         At this level we simply do a visibility test face by face and then
         select the vertices belonging to visible faces.
         """

-        
+

         # Select all vertices, so edges can be displayed even if there are no
         # faces
         for v in mesh.verts:
             v.sel = 1
         # Select all vertices, so edges can be displayed even if there are no
         # faces
         for v in mesh.verts:
             v.sel = 1

-        
+

         Mesh.Mode(Mesh.SelectModes['FACE'])
         # Loop on faces
         for f in mesh.faces:
         Mesh.Mode(Mesh.SelectModes['FACE'])
         # Loop on faces
         for f in mesh.faces:


@@ -2333,7 +2366,7 @@ class Renderer:
             elif mat.getMode() & Material.Modes['SHADELESS']:
                 I = mat.getRGBCol()
                 # Convert to a value between 0 and 255
             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]
+                tmp_col = [int(c * 255.0) for c in I]

 
                 for c in f.col:
                     c.r = tmp_col[0]
 
                 for c in f.col:
                     c.r = tmp_col[0]


@@ -2343,7 +2376,6 @@ class Renderer:
 
                 continue
 
 
                 continue
 

-

             # do vertex color calculation
 
             TotDiffSpec = Vector([0.0, 0.0, 0.0])
             # do vertex color calculation
 
             TotDiffSpec = Vector([0.0, 0.0, 0.0])


@@ -2352,7 +2384,7 @@ class Renderer:
                 light_obj = l
                 light_pos = self._getObjPosition(l)
                 light = light_obj.getData()
                 light_obj = l
                 light_pos = self._getObjPosition(l)
                 light = light_obj.getData()

-            
+

                 L = Vector(light_pos).normalize()
 
                 V = (Vector(camPos) - Vector(f.cent)).normalize()
                 L = Vector(light_pos).normalize()
 
                 V = (Vector(camPos) - Vector(f.cent)).normalize()


@@ -2360,12 +2392,12 @@ class Renderer:
                 N = Vector(f.no).normalize()
 
                 if config.polygons['SHADING'] == 'TOON':
                 N = Vector(f.no).normalize()
 
                 if config.polygons['SHADING'] == 'TOON':

-                    NL = ShadingUtils.toonShading(N*L)
+                    NL = ShadingUtils.toonShading(N * L)

                 else:
                 else:

-                    NL = (N*L)
+                    NL = (N * L)

 
                 # Should we use NL instead of (N*L) here?
 
                 # Should we use NL instead of (N*L) here?

-                R = 2 * (N*L) * N - L
+                R = 2 * (N * L) * N - L

 
                 Ip = light.getEnergy()
 
 
                 Ip = light.getEnergy()
 


@@ -2376,36 +2408,33 @@ class Renderer:
 
                 Idiff = Ip * kd * max(0, NL)
 
 
                 Idiff = Ip * kd * max(0, NL)
 

-

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

-                Ispec = Ip * ks * pow(max(0, (V*R)), ns)
-
-                TotDiffSpec += (Idiff+Ispec)
+                Ispec = Ip * ks * pow(max(0, (V * R)), ns)

 
 

+                TotDiffSpec += (Idiff + Ispec)

 
             # Ambient component
             Iamb = Vector(Blender.World.Get()[0].getAmb())
             ka = mat.getAmb()
 
             # Emissive component (convert to a triplet)
 
             # Ambient component
             Iamb = Vector(Blender.World.Get()[0].getAmb())
             ka = mat.getAmb()
 
             # Emissive component (convert to a triplet)

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

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

 
             # Convert to a value between 0 and 255
 
             # 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]

 
             for c in f.col:
                 c.r = tmp_col[0]
 
             for c in f.col:
                 c.r = tmp_col[0]


@@ -2442,7 +2471,7 @@ class Renderer:
 
         # The Canonical View Volume, 8 vertices, and 6 faces,
         # We consider its face normals pointing outside
 
         # The Canonical View Volume, 8 vertices, and 6 faces,
         # We consider its face normals pointing outside

-        
+

         v1 = NMesh.Vert(1, 1, -1)
         v2 = NMesh.Vert(1, -1, -1)
         v3 = NMesh.Vert(-1, -1, -1)
         v1 = NMesh.Vert(1, 1, -1)
         v2 = NMesh.Vert(1, -1, -1)
         v3 = NMesh.Vert(-1, -1, -1)


@@ -2475,15 +2504,16 @@ class Renderer:
             clippedfaces = []
 
             for f in facelist:
             clippedfaces = []
 
             for f in facelist:

-                
-                newfaces = HSR.splitOn(clipface, f, return_positive_faces=False)
+
+                #newfaces = HSR.splitOn(clipface, f, return_positive_faces=False)
+                newfaces = None

 
                 if not newfaces:
                     # Check if the face is all outside the view frustum
                     # TODO: Do this test before, it is more efficient
                     points_outside = 0
                     for v in f:
 
                 if not newfaces:
                     # Check if the face is all outside the view frustum
                     # TODO: Do this test before, it is more efficient
                     points_outside = 0
                     for v in f:

-                        if abs(v[0]) > 1-EPS or abs(v[1]) > 1-EPS or abs(v[2]) > 1-EPS:
+                        if abs(v[0]) > (1 - EPS) or abs(v[1]) > (1 - EPS) or abs(v[2]) > (1 - EPS):

                             points_outside += 1
 
                     if points_outside != len(f):
                             points_outside += 1
 
                     if points_outside != len(f):


@@ -2500,10 +2530,8 @@ class Renderer:
                         clippedfaces.append(nf)
             facelist = clippedfaces[:]
 
                         clippedfaces.append(nf)
             facelist = clippedfaces[:]
 

-

         nmesh.faces = facelist
         nmesh.update()
         nmesh.faces = facelist
         nmesh.update()

-        

 
     # HSR routines
     def __simpleDepthSort(self, mesh):
 
     # HSR routines
     def __simpleDepthSort(self, mesh):


@@ -2517,10 +2545,10 @@ class Renderer:
 
         # The sorting requires circa n*log(n) steps
         n = len(mesh.faces)
 
         # The sorting requires circa n*log(n) steps
         n = len(mesh.faces)

-        progress.setActivity("HSR: Painter", n*log(n))
+        progress.setActivity("HSR: Painter", n * log(n))

 
         by_furthest_z = (lambda f1, f2: progress.update() and
 
         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])+EPS)
+                cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2]) + EPS)

                 )
 
         # FIXME: using NMesh to sort faces. We should avoid that!
                 )
 
         # FIXME: using NMesh to sort faces. We should avoid that!


@@ -2532,7 +2560,6 @@ class Renderer:
 
         nmesh.update()
 
 
         nmesh.update()
 

-

     def __newellDepthSort(self, mesh):
         """Newell's depth sorting.
 
     def __newellDepthSort(self, mesh):
         """Newell's depth sorting.
 


@@ -2547,7 +2574,6 @@ class Renderer:
         #        print "NON QUAD??"
         #        f.sel = 1
 
         #        print "NON QUAD??"
         #        f.sel = 1
 

-

         # Now reselect all faces
         for f in mesh.faces:
             f.sel = 1
         # Now reselect all faces
         for f in mesh.faces:
             f.sel = 1


@@ -2569,13 +2595,11 @@ class Renderer:
         facelist = nmesh.faces[:]
         maplist = []
 
         facelist = nmesh.faces[:]
         maplist = []
 

-

         # The steps are _at_least_ equal to len(facelist), we do not count the
         # feces coming out from splitting!!
         progress.setActivity("HSR: Newell", len(facelist))
         #progress.setQuiet(True)
 
         # The steps are _at_least_ equal to len(facelist), we do not count the
         # feces coming out from splitting!!
         progress.setActivity("HSR: Newell", len(facelist))
         #progress.setQuiet(True)
 

-        

         while len(facelist):
             debug("\n----------------------\n")
             debug("len(facelits): %d\n" % len(facelist))
         while len(facelist):
             debug("\n----------------------\n")
             debug("len(facelits): %d\n" % len(facelist))


@@ -2599,7 +2623,7 @@ class Renderer:
 
                 qSign = sign(Q.normal[2])
                 # TODO: check also if Q is parallel??
 
                 qSign = sign(Q.normal[2])
                 # TODO: check also if Q is parallel??

- 
+

                 # Test 0: We need to test only those Qs whose furthest vertex
                 # is closer to the observer than the closest vertex of P.
 
                 # Test 0: We need to test only those Qs whose furthest vertex
                 # is closer to the observer than the closest vertex of P.
 


@@ -2617,30 +2641,27 @@ class Renderer:
                         debug("met a marked face\n")
                         continue
 
                         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))
                 # 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))

-                notXOverlap = (min(xQ) >= max(xP)-EPS) or (min(xP) >= max(xQ)-EPS)
+                notXOverlap = min(xQ) >= (max(xP) - EPS) or min(xP) >= (max(xQ) - EPS)

 
                 if notXOverlap:
                     debug("\nTest 1\n")
                     debug("NOT X OVERLAP!\n")
                     continue
 
 
                 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]
                 # 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))
-                notYOverlap = (min(yQ) >= max(yP)-EPS) or (min(yP) >= max(yQ)-EPS)
+                #notYOverlap = max(yP) <= min(yQ) or max(yQ) <= min(yP)
+                notYOverlap = min(yQ) >= (max(yP) - EPS) or min(yP) >= (max(yQ) - EPS)

 
                 if notYOverlap:
                     debug("\nTest 2\n")
                     debug("NOT Y OVERLAP!\n")
                     continue
 
                 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
 
                 # Test 3: P vertices are all behind the plane of Q
                 n = 0


@@ -2655,7 +2676,6 @@ class Renderer:
                     debug("P BEHIND Q!\n")
                     continue
 
                     debug("P BEHIND Q!\n")
                     continue
 

-

                 # Test 4: Q vertices in front of the plane of P
                 n = 0
                 for Qi in Q:
                 # Test 4: Q vertices in front of the plane of P
                 n = 0
                 for Qi in Q:


@@ -2669,12 +2689,11 @@ class Renderer:
                     debug("Q IN FRONT OF P!\n")
                     continue
 
                     debug("Q IN FRONT OF P!\n")
                     continue
 

-

                 # Test 5: Check if projections of polygons effectively overlap,
                 # in previous tests we checked only bounding boxes.
 
                 #if not projectionsOverlap(P, Q):
                 # Test 5: Check if projections of polygons effectively overlap,
                 # in previous tests we checked only bounding boxes.
 
                 #if not projectionsOverlap(P, Q):

-                if not ( HSR.projectionsOverlap(P, Q) or HSR.projectionsOverlap(Q, P)):
+                if not (HSR.projectionsOverlap(P, Q) or HSR.projectionsOverlap(Q, P)):

                     debug("\nTest 5\n")
                     debug("Projections do not overlap!\n")
                     continue
                     debug("\nTest 5\n")
                     debug("Projections do not overlap!\n")
                     continue


@@ -2690,11 +2709,10 @@ class Renderer:
 
                     facelist = HSR.facesplit(P, Q, facelist, nmesh)
                     split_done = 1
 
                     facelist = HSR.facesplit(P, Q, facelist, nmesh)
                     split_done = 1

-                    break 
+                    break

 
                 # The question now is: Does Q obscure P?
 
 
                 # 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:
                 # Test 3bis: Q vertices are all behind the plane of P
                 n = 0
                 for Qi in Q:


@@ -2707,7 +2725,6 @@ class Renderer:
                     debug("\nTest 3bis\n")
                     debug("Q BEHIND P!\n")
 
                     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:
                 # Test 4bis: P vertices in front of the plane of Q
                 n = 0
                 for Pi in P:


@@ -2720,7 +2737,6 @@ class Renderer:
                     debug("\nTest 4bis\n")
                     debug("P IN FRONT OF Q!\n")
 
                     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:
                 # 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:


@@ -2730,27 +2746,26 @@ class Renderer:
 
                     facelist = HSR.facesplit(P, Q, facelist, nmesh)
                     split_done = 1
 
                     facelist = HSR.facesplit(P, Q, facelist, nmesh)
                     split_done = 1

-                    break 
-                    
+                    break
+

                 facelist.remove(Q)
                 facelist.insert(0, Q)
                 Q.smooth = 1
                 face_marked = 1
                 debug("Q marked!\n")
                 break
                 facelist.remove(Q)
                 facelist.insert(0, Q)
                 Q.smooth = 1
                 face_marked = 1
                 debug("Q marked!\n")
                 break

- 
-            # Write P!                     
+
+            # Write P!

             if split_done == 0 and face_marked == 0:
                 facelist.remove(P)
                 maplist.append(P)
             if split_done == 0 and face_marked == 0:
                 facelist.remove(P)
                 maplist.append(P)

-                dumpfaces(maplist, "dump"+str(len(maplist)).zfill(4)+".svg")
+                dumpfaces(maplist, "dump" + str(len(maplist)).zfill(4) + ".svg")

 
                 progress.update()
 
             if len(facelist) == 870:
                 dumpfaces([P, Q], "loopdebug.svg")
 
 
                 progress.update()
 
             if len(facelist) == 870:
                 dumpfaces([P, Q], "loopdebug.svg")
 

-

             #if facelist == None:
             #    maplist = [P, Q]
             #    print [v.co for v in P]
             #if facelist == None:
             #    maplist = [P, Q]
             #    print [v.co for v in P]


@@ -2758,7 +2773,6 @@ class Renderer:
             #    break
 
             # end of while len(facelist)
             #    break
 
             # end of while len(facelist)

-         

 
         nmesh.faces = maplist
         #for f in nmesh.faces:
 
         nmesh.faces = maplist
         #for f in nmesh.faces:


@@ -2766,7 +2780,6 @@ class Renderer:
 
         nmesh.update()
 
 
         nmesh.update()
 

-

     def _doHiddenSurfaceRemoval(self, mesh):
         """Do HSR for the given mesh.
         """
     def _doHiddenSurfaceRemoval(self, mesh):
         """Do HSR for the given mesh.
         """


@@ -2781,7 +2794,6 @@ class Renderer:
             print "\nUsing the Newell's algorithm for HSR."
             self.__newellDepthSort(mesh)
 
             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.
 
     def _doEdgesStyle(self, mesh, edgestyleSelect):
         """Process Mesh Edges accroding to a given selection style.
 


@@ -2800,7 +2812,7 @@ class Renderer:
 
         edge_cache = MeshUtils.buildEdgeFaceUsersCache(mesh)
 
 
         edge_cache = MeshUtils.buildEdgeFaceUsersCache(mesh)
 

-        for i,edge_faces in enumerate(edge_cache):
+        for i, edge_faces in enumerate(edge_cache):

             mesh.edges[i].sel = 0
             if edgestyleSelect(edge_faces):
                 mesh.edges[i].sel = 1
             mesh.edges[i].sel = 0
             if edgestyleSelect(edge_faces):
                 mesh.edges[i].sel = 1


@@ -2821,17 +2833,17 @@ class Renderer:
 #
 # ---------------------------------------------------------------------
 
 #
 # ---------------------------------------------------------------------
 

-

 from Blender import BGL, Draw
 from Blender.BGL import *
 
 from Blender import BGL, Draw
 from Blender.BGL import *
 

+

 class GUI:
 class GUI:

-    
+

     def _init():
 
     def _init():
 

-        # Output Format menu 
+        # Output Format menu

         output_format = config.output['FORMAT']
         output_format = config.output['FORMAT']

-        default_value = outputWriters.keys().index(output_format)+1
+        default_value = outputWriters.keys().index(output_format) + 1

         GUI.outFormatMenu = Draw.Create(default_value)
         GUI.evtOutFormatMenu = 0
 
         GUI.outFormatMenu = Draw.Create(default_value)
         GUI.evtOutFormatMenu = 0
 


@@ -2846,9 +2858,9 @@ class GUI:
         # Render filled polygons
         GUI.polygonsToggle = Draw.Create(config.polygons['SHOW'])
 
         # Render filled polygons
         GUI.polygonsToggle = Draw.Create(config.polygons['SHOW'])
 

-        # Shading Style menu 
+        # Shading Style menu

         shading_style = config.polygons['SHADING']
         shading_style = config.polygons['SHADING']

-        default_value = shadingStyles.keys().index(shading_style)+1
+        default_value = shadingStyles.keys().index(shading_style) + 1

         GUI.shadingStyleMenu = Draw.Create(default_value)
         GUI.evtShadingStyleMenu = 21
 
         GUI.shadingStyleMenu = Draw.Create(default_value)
         GUI.evtShadingStyleMenu = 21
 


@@ -2863,9 +2875,9 @@ class GUI:
         GUI.showHiddenEdgesToggle = Draw.Create(config.edges['SHOW_HIDDEN'])
         GUI.evtShowHiddenEdgesToggle = 5
 
         GUI.showHiddenEdgesToggle = Draw.Create(config.edges['SHOW_HIDDEN'])
         GUI.evtShowHiddenEdgesToggle = 5
 

-        # Edge Style menu 
+        # Edge Style menu

         edge_style = config.edges['STYLE']
         edge_style = config.edges['STYLE']

-        default_value = edgeStyles.keys().index(edge_style)+1
+        default_value = edgeStyles.keys().index(edge_style) + 1

         GUI.edgeStyleMenu = Draw.Create(default_value)
         GUI.evtEdgeStyleMenu = 6
 
         GUI.edgeStyleMenu = Draw.Create(default_value)
         GUI.evtEdgeStyleMenu = 6
 


@@ -2875,7 +2887,7 @@ class GUI:
 
         # Edge Color Picker
         c = config.edges['COLOR']
 
         # Edge Color Picker
         c = config.edges['COLOR']

-        GUI.edgeColorPicker = Draw.Create(c[0]/255.0, c[1]/255.0, c[2]/255.0)
+        GUI.edgeColorPicker = Draw.Create(c[0] / 255.0, c[1] / 255.0, c[2] / 255.0)

         GUI.evtEdgeColorPicker = 71
 
         # Render Button
         GUI.evtEdgeColorPicker = 71
 
         # Render Button


@@ -2884,6 +2896,9 @@ class GUI:
         # Exit Button
         GUI.evtExitButton = 9
 
         # Exit Button
         GUI.evtExitButton = 9
 

+        # Save default button
+        GUI.evtSaveDefaultButton = 99
+

     def draw():
 
         # initialize static members
     def draw():
 
         # initialize static members


@@ -2891,9 +2906,12 @@ class GUI:
 
         glClear(GL_COLOR_BUFFER_BIT)
         glColor3f(0.0, 0.0, 0.0)
 
         glClear(GL_COLOR_BUFFER_BIT)
         glColor3f(0.0, 0.0, 0.0)

-        glRasterPos2i(10, 350)
+        glRasterPos2i(10, 380)

         Draw.Text("VRM: Vector Rendering Method script. Version %s." %
                 __version__)
         Draw.Text("VRM: Vector Rendering Method script. Version %s." %
                 __version__)

+        glRasterPos2i(10, 365)
+        Draw.Text("%s (c) 2012" % __author__)
+

         glRasterPos2i(10, 335)
         Draw.Text("Press Q or ESC to quit.")
 
         glRasterPos2i(10, 335)
         Draw.Text("Press Q or ESC to quit.")
 


@@ -2902,24 +2920,27 @@ class GUI:
         Draw.Text("Select the output Format:")
         outMenuStruct = "Output Format %t"
         for t in outputWriters.keys():
         Draw.Text("Select the output Format:")
         outMenuStruct = "Output Format %t"
         for t in outputWriters.keys():

-           outMenuStruct = outMenuStruct + "|%s" % t
+            outMenuStruct = outMenuStruct + "|%s" % t

         GUI.outFormatMenu = Draw.Menu(outMenuStruct, GUI.evtOutFormatMenu,
         GUI.outFormatMenu = Draw.Menu(outMenuStruct, GUI.evtOutFormatMenu,

-                10, 285, 160, 18, GUI.outFormatMenu.val, "Choose the Output Format")
+            10, 285, 160, 18, GUI.outFormatMenu.val, "Choose the Output Format")

 
         # Animation toggle
         GUI.animToggle = Draw.Toggle("Animation", GUI.evtAnimToggle,
 
         # Animation toggle
         GUI.animToggle = Draw.Toggle("Animation", GUI.evtAnimToggle,

-                10, 260, 160, 18, GUI.animToggle.val,
-                "Toggle rendering of animations")
+            10, 260, 160, 18, GUI.animToggle.val,
+            "Toggle rendering of animations")

 
         # Join Objects toggle
         GUI.joinObjsToggle = Draw.Toggle("Join objects", GUI.evtJoinObjsToggle,
 
         # Join Objects toggle
         GUI.joinObjsToggle = Draw.Toggle("Join objects", GUI.evtJoinObjsToggle,

-                10, 235, 160, 18, GUI.joinObjsToggle.val,
-                "Join objects in the rendered file")
+            10, 235, 160, 18, GUI.joinObjsToggle.val,
+            "Join objects in the rendered file")

 
         # Render Button
 
         # 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!")
+        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!")
+
+        Draw.Button("Save settings as default", GUI.evtSaveDefaultButton, 10, 210 - 50, 160, 18,
+            "Save settings as default")

 
         # Rendering Styles
         glRasterPos2i(200, 310)
 
         # Rendering Styles
         glRasterPos2i(200, 310)


@@ -2927,8 +2948,8 @@ class GUI:
 
         # Render Polygons
         GUI.polygonsToggle = Draw.Toggle("Filled Polygons", GUI.evtPolygonsToggle,
 
         # Render Polygons
         GUI.polygonsToggle = Draw.Toggle("Filled Polygons", GUI.evtPolygonsToggle,

-                200, 285, 160, 18, GUI.polygonsToggle.val,
-                "Render filled polygons")
+            200, 285, 160, 18, GUI.polygonsToggle.val,
+            "Render filled polygons")

 
         if GUI.polygonsToggle.val == 1:
 
 
         if GUI.polygonsToggle.val == 1:
 


@@ -2937,42 +2958,38 @@ class GUI:
             for t in shadingStyles.keys():
                 shadingStyleMenuStruct = shadingStyleMenuStruct + "|%s" % t.lower()
             GUI.shadingStyleMenu = Draw.Menu(shadingStyleMenuStruct, GUI.evtShadingStyleMenu,
             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")
-
+                200, 260, 160, 18, GUI.shadingStyleMenu.val,
+                "Choose the shading style")

 
         # Render Edges
         GUI.showEdgesToggle = Draw.Toggle("Show Edges", GUI.evtShowEdgesToggle,
 
         # Render Edges
         GUI.showEdgesToggle = Draw.Toggle("Show Edges", GUI.evtShowEdgesToggle,

-                200, 235, 160, 18, GUI.showEdgesToggle.val,
-                "Render polygon edges")
+            200, 235, 160, 18, GUI.showEdgesToggle.val,
+            "Render polygon edges")

 
         if GUI.showEdgesToggle.val == 1:
 
         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,
             # 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")
+                200, 210, 160, 18, GUI.edgeStyleMenu.val,
+                "Choose the edge style")

 
             # Edge size
             GUI.edgeWidthSlider = Draw.Slider("Width: ", GUI.evtEdgeWidthSlider,
 
             # Edge size
             GUI.edgeWidthSlider = Draw.Slider("Width: ", GUI.evtEdgeWidthSlider,

-                    200, 185, 140, 18, GUI.edgeWidthSlider.val,
-                    0.0, 10.0, 0, "Change Edge Width")
+                200, 185, 140, 18, GUI.edgeWidthSlider.val,
+                0.0, 10.0, 0, "Change Edge Width")

 
             # Edge Color
             GUI.edgeColorPicker = Draw.ColorPicker(GUI.evtEdgeColorPicker,
 
             # Edge Color
             GUI.edgeColorPicker = Draw.ColorPicker(GUI.evtEdgeColorPicker,

-                    342, 185, 18, 18, GUI.edgeColorPicker.val, "Choose Edge Color")
+                342, 185, 18, 18, GUI.edgeColorPicker.val, "Choose Edge Color")

 
             # Show Hidden Edges
             GUI.showHiddenEdgesToggle = Draw.Toggle("Show Hidden Edges",
 
             # 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__)
+                GUI.evtShowHiddenEdgesToggle,
+                200, 160, 160, 18, GUI.showHiddenEdgesToggle.val,
+                "Render hidden edges as dashed lines")

 
     def event(evt, val):
 
 
     def event(evt, val):
 


@@ -2990,7 +3007,7 @@ class GUI:
 
         elif evt == GUI.evtOutFormatMenu:
             i = GUI.outFormatMenu.val - 1
 
         elif evt == GUI.evtOutFormatMenu:
             i = GUI.outFormatMenu.val - 1

-            config.output['FORMAT']= outputWriters.keys()[i]
+            config.output['FORMAT'] = outputWriters.keys()[i]

             # Set the new output file
             global outputfile
             outputfile = Blender.sys.splitext(basename)[0] + "." + str(config.output['FORMAT']).lower()
             # Set the new output file
             global outputfile
             outputfile = Blender.sys.splitext(basename)[0] + "." + str(config.output['FORMAT']).lower()


@@ -3022,7 +3039,7 @@ class GUI:
             config.edges['WIDTH'] = float(GUI.edgeWidthSlider.val)
 
         elif evt == GUI.evtEdgeColorPicker:
             config.edges['WIDTH'] = float(GUI.edgeWidthSlider.val)
 
         elif evt == GUI.evtEdgeColorPicker:

-            config.edges['COLOR'] = [int(c*255.0) for c in GUI.edgeColorPicker.val]
+            config.edges['COLOR'] = [int(c * 255.0) for c in GUI.edgeColorPicker.val]

 
         elif evt == GUI.evtRenderButton:
             label = "Save %s" % config.output['FORMAT']
 
         elif evt == GUI.evtRenderButton:
             label = "Save %s" % config.output['FORMAT']


@@ -3030,6 +3047,9 @@ class GUI:
             global outputfile
             Blender.Window.FileSelector(vectorize, label, outputfile)
 
             global outputfile
             Blender.Window.FileSelector(vectorize, label, outputfile)
 

+        elif evt == GUI.evtSaveDefaultButton:
+            config.saveToRegistry()
+

         else:
             print "Event: %d not handled!" % evt
 
         else:
             print "Event: %d not handled!" % evt
 


@@ -3050,10 +3070,11 @@ class GUI:
     button_event = staticmethod(button_event)
     conf_debug = staticmethod(conf_debug)
 
     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:
 # A wrapper function for the vectorizing process
 def vectorize(filename):
     """The vectorizing process is as follows:

-     
+

      - Instanciate the writer and the renderer
      - Render!
      """
      - Instanciate the writer and the renderer
      - Render!
      """


@@ -3064,16 +3085,17 @@ def vectorize(filename):
 
     from Blender import Window
     editmode = Window.EditMode()
 
     from Blender import Window
     editmode = Window.EditMode()

-    if editmode: Window.EditMode(0)
+    if editmode:
+        Window.EditMode(0)

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

-    
+

     renderer = Renderer()
     renderer.doRendering(writer, config.output['ANIMATION'])
 
     renderer = Renderer()
     renderer.doRendering(writer, config.output['ANIMATION'])
 

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

 
 
 # Here the main
 
 
 # Here the main


@@ -3081,6 +3103,13 @@ if __name__ == "__main__":
 
     global progress
 
 
     global progress
 

+    config.loadFromRegistry()
+
+    # initialize writer setting also here to configure writer specific
+    # settings on startup
+    actualWriter = outputWriters[config.output['FORMAT']]
+    writer = actualWriter("")
+

     outputfile = ""
     basename = Blender.sys.basename(Blender.Get('filename'))
     if basename != "":
     outputfile = ""
     basename = Blender.sys.basename(Blender.Get('filename'))
     if basename != "":