SWF output support
[vrm.git] / vrm.py
diff --git a/vrm.py b/vrm.py
index bc44cfd..26a14d7 100755 (executable)
--- a/vrm.py
+++ b/vrm.py
@@ -76,6 +76,9 @@ __bpydoc__ = """\
 #     * 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
+#     * Fixed a bug in the animation code, now the projection matrix is
+#       recalculated at each frame!
 #
 # ---------------------------------------------------------------------
 
@@ -85,6 +88,12 @@ from Blender.Mathutils import *
 from math import *
 import sys, time
 
+# Constants
+EPS = 10e-5
+
+# We use a global progress Indicator Object
+progress = None
+
 
 # Some global settings
 
@@ -92,8 +101,8 @@ class config:
     polygons = dict()
     polygons['SHOW'] = True
     polygons['SHADING'] = 'FLAT'
-    polygons['HSR'] = 'PAINTER' # 'PAINTER' or 'NEWELL'
-    #polygons['HSR'] = 'NEWELL'
+    #polygons['HSR'] = 'PAINTER' # 'PAINTER' or 'NEWELL'
+    polygons['HSR'] = 'PAINTER'
     # Hidden to the user for now
     polygons['EXPANSION_TRICK'] = True
 
@@ -102,22 +111,28 @@ class config:
     edges = dict()
     edges['SHOW'] = False
     edges['SHOW_HIDDEN'] = False
-    edges['STYLE'] = 'MESH'
+    edges['STYLE'] = 'MESH' # or SILHOUETTE
+    edges['STYLE'] = 'SILHOUETTE'
     edges['WIDTH'] = 2
     edges['COLOR'] = [0, 0, 0]
 
     output = dict()
     output['FORMAT'] = 'SVG'
-    output['ANIMATION'] = False
+    output['FORMAT'] = 'SWF'
+    output['ANIMATION'] = True
     output['JOIN_OBJECTS'] = True
 
 
 
-# Debug utility function
-print_debug = False
-def debug(msg):
-    if print_debug:
-        sys.stderr.write(msg)
+# Utility functions
+def sign(x):
+
+    if x < -EPS:
+        return -1
+    elif x > EPS:
+        return 1
+    else:
+        return 0
 
 
 # ---------------------------------------------------------------------
@@ -436,8 +451,13 @@ class ProgressIndicator:
         self.refresh_rate = 10
         self.shows_counter = 0
 
+        self.quiet = False
+
         self.progressModel = None
 
+    def setQuiet(self, value):
+        self.quiet = value
+
     def setActivity(self, name, steps):
         """Initialize the Model.
 
@@ -457,6 +477,9 @@ class ProgressIndicator:
         assert(self.progressModel)
 
         if self.progressModel.update():
+            if self.quiet:
+                return
+
             self.show(self.progressModel.getProgress(),
                     self.progressModel.getName())
 
@@ -593,7 +616,8 @@ class VectorWriter:
         return
 
     def close(self):
-        self.file.close()
+        if self.file:
+            self.file.close()
         return
 
     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
@@ -793,6 +817,7 @@ class SVGVectorWriter(VectorWriter):
             if color[3] != 255:
                 opacity = float(color[3])/255.0
                 opacity_string = " fill-opacity: %g; stroke-opacity: %g; opacity: 1;" % (opacity, opacity)
+                #opacity_string = "opacity: %g;" % (opacity)
 
             self.file.write("\tstyle=\"fill:" + str_col + ";")
             self.file.write(opacity_string)
@@ -802,7 +827,9 @@ class SVGVectorWriter(VectorWriter):
             # see http://www.antigrain.com/svg/index.html for more info
             stroke_width = 1.0
 
-            if config.polygons['EXPANSION_TRICK']:
+            # EXPANSION TRICK is not that useful where there is transparency
+            if config.polygons['EXPANSION_TRICK'] and color[3] == 255:
+                # str_col = "#000000" # For debug
                 self.file.write(" stroke:%s;\n" % str_col)
                 self.file.write(" stroke-width:" + str(stroke_width) + ";\n")
                 self.file.write(" stroke-linecap:round;stroke-linejoin:round")
@@ -844,6 +871,196 @@ class SVGVectorWriter(VectorWriter):
         self.file.write("</g>\n")
 
 
+## SWF Writer
+
+from ming import *
+
+class SWFVectorWriter(VectorWriter):
+    """A concrete class for writing SWF output.
+    """
+
+    def __init__(self, fileName):
+        """Simply call the parent Contructor.
+        """
+        VectorWriter.__init__(self, fileName)
+
+        self.movie = None
+        self.sprite = None
+
+
+    ##
+    # Public Methods
+    #
+
+    def open(self, startFrame=1, endFrame=1):
+        """Do some initialization operations.
+        """
+        VectorWriter.open(self, startFrame, endFrame)
+        self.movie = SWFMovie()
+        self.movie.setDimension(self.canvasSize[0], self.canvasSize[1])
+        # set fps
+        self.movie.setRate(25)
+        numframes = endFrame - startFrame + 1
+        self.movie.setFrames(numframes)
+
+    def close(self):
+        """Do some finalization operation.
+        """
+        self.movie.save(self.outputFileName)
+
+        # remember to call the close method of the parent
+        VectorWriter.close(self)
+
+    def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
+            showHiddenEdges=False):
+        """Convert the scene representation to SVG.
+        """
+        context = scene.getRenderingContext()
+        framenumber = context.currentFrame()
+
+        Objects = scene.getChildren()
+
+        if self.sprite:
+            self.movie.remove(self.sprite)
+
+        sprite = SWFSprite()
+
+        for obj in Objects:
+
+            if(obj.getType() != 'Mesh'):
+                continue
+
+            mesh = obj.getData(mesh=1)
+
+            if doPrintPolygons:
+                self._printPolygons(mesh, sprite)
+
+            if doPrintEdges:
+                self._printEdges(mesh, sprite, showHiddenEdges)
+            
+        sprite.nextFrame()
+        i = self.movie.add(sprite)
+        # Remove the instance the next time
+        self.sprite = i
+        if self.animation:
+            self.movie.nextFrame()
+
+    
+    ##  
+    # Private Methods
+    #
+    
+    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
+
+        # rescale to canvas size
+        pt[0] = v.co[0]*mW + mW
+        pt[1] = v.co[1]*mH + mH
+        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]
+        
+        return pt
+                
+    def _printPolygons(self, mesh, sprite): 
+        """Print the selected (visible) polygons.
+        """
+
+        if len(mesh.faces) == 0:
+            return
+
+        for face in mesh.faces:
+            if not face.sel:
+               continue
+
+            if face.col:
+                fcol = face.col[0]
+                color = [fcol.r, fcol.g, fcol.b, fcol.a]
+            else:
+                color = [255, 255, 255, 255]
+
+            s = SWFShape()
+            f = s.addFill(color[0], color[1], color[2], color[3])
+            s.setRightFill(f)
+
+            # The starting point of the shape
+            p0 = self._calcCanvasCoord(face.verts[0])
+            s.movePenTo(p0[0], p0[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)
+
+
+            """
+            # use the stroke property to alleviate the "adjacent edges" problem,
+            # we simulate polygon expansion using borders,
+            # see http://www.antigrain.com/svg/index.html for more info
+            stroke_width = 1.0
+
+            # EXPANSION TRICK is not that useful where there is transparency
+            if config.polygons['EXPANSION_TRICK'] and color[3] == 255:
+                # str_col = "#000000" # For debug
+                self.file.write(" stroke:%s;\n" % str_col)
+                self.file.write(" stroke-width:" + str(stroke_width) + ";\n")
+                self.file.write(" stroke-linecap:round;stroke-linejoin:round")
+
+            """
+
+    def _printEdges(self, mesh, sprite, showHiddenEdges=False):
+        """Print the wireframe using mesh edges.
+        """
+
+        stroke_width = config.edges['WIDTH']
+        stroke_col = config.edges['COLOR']
+
+        s = SWFShape()
+
+        for e in mesh.edges:
+
+            #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
+                    s.setLine(stroke_width/2, stroke_col[0], stroke_col[1],
+                            stroke_col[2], 128)
+
+            p1 = self._calcCanvasCoord(e.v1)
+            p2 = self._calcCanvasCoord(e.v2)
+
+            # FIXME: this is just a qorkaround, remove that after the
+            # implementation of propoer Viewport clipping
+            if abs(p1[0]) < 3000 and abs(p2[0]) < 3000 and abs(p1[1]) < 3000 and abs(p1[2]) < 3000:
+                s.movePenTo(p1[0], p1[1])
+                s.drawLineTo(p2[0], p2[1])
+            
+
+        s.end()
+        sprite.add(s)
+            
+
+
 # ---------------------------------------------------------------------
 #
 ## Rendering Classes
@@ -863,6 +1080,7 @@ edgeStyles['SILHOUETTE'] = MeshUtils.isSilhouetteEdge
 # A dictionary to collect the supported output formats
 outputWriters = dict()
 outputWriters['SVG'] = SVGVectorWriter
+outputWriters['SWF'] = SWFVectorWriter
 
 
 class Renderer:
@@ -895,12 +1113,6 @@ class Renderer:
         # Render from the currently active camera 
         self.cameraObj = self._SCENE.getCurrentCamera()
 
-        # Get a projector for this camera.
-        # NOTE: the projector wants object in world coordinates,
-        # so we should remember to apply modelview transformations
-        # _before_ we do projection transformations.
-        self.proj = Projector(self.cameraObj, self.canvasRatio)
-
         # Get the list of lighting sources
         obj_lst = self._SCENE.getChildren()
         self.lights = [ o for o in obj_lst if o.getType() == 'Lamp']
@@ -952,6 +1164,12 @@ class Renderer:
             # And Set our camera accordingly
             self.cameraObj = inputScene.getCurrentCamera()
 
+            # Get a projector for this camera.
+            # NOTE: the projector wants object in world coordinates,
+            # so we should remember to apply modelview transformations
+            # _before_ we do projection transformations.
+            self.proj = Projector(self.cameraObj, self.canvasRatio)
+
             try:
                 renderedScene = self.doRenderScene(inputScene)
             except :
@@ -1002,6 +1220,7 @@ class Renderer:
         Objects = workScene.getChildren()
         print "Total Objects: %d" % len(Objects)
         for i,obj in enumerate(Objects):
+            print "\n\n-------"
             print "Rendering Object: %d" % i
 
             if obj.getType() != 'Mesh':
@@ -1016,6 +1235,16 @@ class Renderer:
 
             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:
+                    f.sel = 1-f.sel
+                mesh.flipNormals()
+                for f in mesh.faces:
+                    f.sel = 1
+
             self._doLighting(mesh)
 
             # Do "projection" now so we perform further processing
@@ -1028,7 +1257,6 @@ class Renderer:
 
             self._doEdgesStyle(mesh, edgeStyles[config.edges['STYLE']])
 
-            
             # Update the object data, important! :)
             mesh.update()
 
@@ -1135,6 +1363,7 @@ class Renderer:
         """Convert all "geometric" objects to mesh ones.
         """
         geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text']
+        #geometricObjTypes = ['Mesh', 'Surf', 'Curve']
 
         Objects = scene.getChildren()
         objList = [ o for o in Objects if o.getType() in geometricObjTypes ]
@@ -1296,26 +1525,26 @@ class Renderer:
             mat = None
             if materials:
                 mat = materials[f.mat]
-                # Check if it is a shadeless material
-                if mat.getMode() & Material.Modes['SHADELESS']:
-                    I = mat.getRGBCol()
-                    # Convert to a value between 0 and 255
-                    tmp_col = [ int(c * 255.0) for c in I]
-
-                    for c in f.col:
-                        c.r = tmp_col[0]
-                        c.g = tmp_col[1]
-                        c.b = tmp_col[2]
-                        #c.a = tmp_col[3]
-
-                    continue
-
-
 
             # A new default material
             if mat == None:
                 mat = Material.New('defMat')
 
+            # Check if it is a shadeless material
+            elif mat.getMode() & Material.Modes['SHADELESS']:
+                I = mat.getRGBCol()
+                # Convert to a value between 0 and 255
+                tmp_col = [ int(c * 255.0) for c in I]
+
+                for c in f.col:
+                    c.r = tmp_col[0]
+                    c.g = tmp_col[1]
+                    c.b = tmp_col[2]
+                    #c.a = tmp_col[3]
+
+                continue
+
+
             # do vertex color calculation
 
             TotDiffSpec = Vector([0.0, 0.0, 0.0])
@@ -1323,7 +1552,7 @@ class Renderer:
             for l in self.lights:
                 light_obj = l
                 light_pos = self._getObjPosition(l)
-                light = light_obj.data
+                light = light_obj.getData()
             
                 L = Vector(light_pos).normalize()
 
@@ -1420,14 +1649,14 @@ class Renderer:
         solves HSR correctly only for convex meshes.
         """
 
-        global progress
+        #global progress
+
         # The sorting requires circa n*log(n) steps
         n = len(mesh.faces)
         progress.setActivity("HSR: Painter", n*log(n))
-        
 
         by_furthest_z = (lambda f1, f2: progress.update() and
-                cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2]))
+                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!
@@ -1439,42 +1668,27 @@ class Renderer:
 
         nmesh.update()
 
-    def __topologicalDepthSort(self, mesh):
-        """Occlusion based on topological occlusion.
-        
-        Build the occlusion graph of the mesh,
-        and then do topological sort on that graph
-        """
-        return
 
     def __newellDepthSort(self, mesh):
         """Newell's depth sorting.
 
         """
-        by_furthest_z = (lambda f1, f2:
-                cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2]))
-                )
-
-        def Distance(point, face):
-            """ Calculate the distance between a point and a face.
-
-            An alternative but more expensive method can be:
-
-                ip = Intersect(Vector(face[0]), Vector(face[1]), Vector(face[2]),
-                        Vector(face.no), Vector(point), 0)
-
-                d = Vector(ip - point).length
-            """
+        from hsrtk import *
 
-            plNormal = Vector(face.no)
-            plVert0 = Vector(face[0])
+        #global progress
 
-            #d = abs( (point * plNormal ) - (plVert0 * plNormal) )
-            d = (point * plNormal ) - (plVert0 * plNormal)
-            debug("d: "+ str(d) + "\n")
+        # Find non planar quads and convert them to triangle
+        #for f in mesh.faces:
+        #    f.sel = 0
+        #    if is_nonplanar_quad(f.v):
+        #        print "NON QUAD??"
+        #        f.sel = 1
 
-            return d
 
+        # Now reselect all faces
+        for f in mesh.faces:
+            f.sel = 1
+        mesh.quadToTriangle()
 
         # FIXME: using NMesh to sort faces. We should avoid that!
         nmesh = NMesh.GetRaw(mesh.name)
@@ -1483,7 +1697,6 @@ class Renderer:
         nmesh.faces.sort(by_furthest_z)
         nmesh.faces.reverse()
 
-        
         # Begin depth sort tests
 
         # use the smooth flag to set marked faces
@@ -1493,17 +1706,27 @@ class Renderer:
         facelist = nmesh.faces[:]
         maplist = []
 
-        EPS = 10e-7
 
-        global progress
+        # 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))
             P = facelist[0]
 
-            pSign = 1
-            if P.sel == 0:
-                pSign = -1
+            pSign = sign(P.normal[2])
+
+            # We can discard faces parallel to the view vector
+            #if P.normal[2] == 0:
+            #    facelist.remove(P)
+            #    continue
+
+            split_done = 0
+            face_marked = 0
 
             for Q in facelist[1:]:
 
@@ -1511,38 +1734,48 @@ class Renderer:
                 debug("Q.smooth: " + str(Q.smooth) + "\n")
                 debug("\n")
 
-                qSign = 1
-                if Q.sel == 0:
-                    qSign = -1
-
-                # We need to test only those Qs whose furthest vertex
+                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.
 
                 zP = [v.co[2] for v in P.v]
                 zQ = [v.co[2] for v in Q.v]
-                ZOverlap = min(zP) < max(zQ)
+                notZOverlap = min(zP) > max(zQ) + EPS
 
-                if not ZOverlap:
-                    if not Q.smooth:
-                        # We can safely print P
+                if notZOverlap:
+                    debug("\nTest 0\n")
+                    debug("NOT Z OVERLAP!\n")
+                    if Q.smooth == 0:
+                        # If Q is not marked then we can safely print P
                         break
                     else:
+                        debug("met a marked face\n")
                         continue
+
                 
                 # Test 1: X extent overlapping
                 xP = [v.co[0] for v in P.v]
                 xQ = [v.co[0] for v in Q.v]
-                notXOverlap = (max(xP) < min(xQ)) or (max(xQ) < min(xP))
+                #notXOverlap = (max(xP) <= min(xQ)) or (max(xQ) <= min(xP))
+                notXOverlap = (min(xQ) >= max(xP)-EPS) or (min(xP) >= max(xQ)-EPS)
 
                 if notXOverlap:
+                    debug("\nTest 1\n")
+                    debug("NOT X OVERLAP!\n")
                     continue
 
+
                 # Test 2: Y extent Overlapping
                 yP = [v.co[1] for v in P.v]
                 yQ = [v.co[1] for v in Q.v]
-                notYOverlap = (max(yP) < min(yQ)) or (max(yQ) < min(yP))
+                #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
                 
 
@@ -1550,7 +1783,7 @@ class Renderer:
                 n = 0
                 for Pi in P:
                     d = qSign * Distance(Vector(Pi), Q)
-                    if d < EPS:
+                    if d <= EPS:
                         n += 1
                 pVerticesBehindPlaneQ = (n == len(P))
 
@@ -1564,7 +1797,7 @@ class Renderer:
                 n = 0
                 for Qi in Q:
                     d = pSign * Distance(Vector(Qi), P)
-                    if d >= EPS:
+                    if d >= -EPS:
                         n += 1
                 qVerticesInFrontPlaneP = (n == len(Q))
 
@@ -1573,84 +1806,98 @@ class Renderer:
                     debug("Q IN FRONT OF P!\n")
                     continue
 
-                # Test 5: Line Intersections... TODO
 
+                # Test 5: Check if projections of polygons effectively overlap,
+                # in previous tests we checked only bounding boxes.
+
+                if not projectionsOverlap(P, Q):
+                    debug("\nTest 5\n")
+                    debug("Projections do not overlap!\n")
+                    continue
+
+                # We still can't say if P obscures Q.
 
-                # We do not know if P obscures Q.
+                # But if Q is marked we do a face-split trying to resolve a
+                # difficulty (maybe a visibility cycle).
                 if Q.smooth == 1:
-                    # Split P or Q, TODO
+                    # Split P or Q
+                    debug("Possibly a cycle detected!\n")
                     debug("Split here!!\n")
-                    continue
 
+                    facelist = facesplit(P, Q, facelist, nmesh)
+                    split_done = 1
+                    break 
 
                 # The question now is: Does Q obscure P?
 
+
                 # Test 3bis: Q vertices are all behind the plane of P
                 n = 0
                 for Qi in Q:
                     d = pSign * Distance(Vector(Qi), P)
-                    if d < EPS:
+                    if d <= EPS:
                         n += 1
                 qVerticesBehindPlaneP = (n == len(Q))
 
+                if qVerticesBehindPlaneP:
+                    debug("\nTest 3bis\n")
+                    debug("Q BEHIND P!\n")
+
 
                 # Test 4bis: P vertices in front of the plane of Q
                 n = 0
                 for Pi in P:
                     d = qSign * Distance(Vector(Pi), Q)
-                    if d >= EPS:
+                    if d >= -EPS:
                         n += 1
                 pVerticesInFrontPlaneQ = (n == len(P))
 
+                if pVerticesInFrontPlaneQ:
+                    debug("\nTest 4bis\n")
+                    debug("P IN FRONT OF Q!\n")
 
-                """
-                import intersection
-
+                
+                # 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:
-                    # Split P or Q, TODO
-                    print "Test 3bis or 4bis failed"
-                    print "Split here!!2\n"
-
-                    newfaces = intersection.splitOn(nmesh, P, Q, 0)
-                    facelist.remove(Q)
-                    for nf in newfaces:
-                        if nf:
-                            nf.col = Q.col
-                            facelist.append(nf)
-
-                    break
-
-                # We do not know
-                if Q.smooth:
-                    # split P or Q
-                    print "Split here!!\n"
-                    newfaces = intersection.splitOn(nmesh, P, Q, 0)
-                    facelist.remove(Q)
-                    for nf in newfaces:
-                        if nf:
-                            nf.col = Q.col
-                            facelist.append(nf)
-
-                    break
-                """ 
-
-                Q.smooth = 1
+                    debug("\nSimple Intersection?\n")
+                    debug("Test 3bis or 4bis failed\n")
+                    debug("Split here!!2\n")
+
+                    facelist = facesplit(P, Q, facelist, nmesh)
+                    split_done = 1
+                    break 
+                    
                 facelist.remove(Q)
                 facelist.insert(0, Q)
+                Q.smooth = 1
+                face_marked = 1
+                debug("Q marked!\n")
+                break
            
             # Write P!                     
-            facelist.remove(P)
-            maplist.append(P)
+            if split_done == 0 and face_marked == 0:
+                facelist.remove(P)
+                maplist.append(P)
 
-            progress.update()
+                progress.update()
 
-        
-        nmesh.faces = maplist
+            #if facelist == None:
+            #    maplist = [P, Q]
+            #    print [v.co for v in P]
+            #    print [v.co for v in Q]
+            #    break
+
+            # end of while len(facelist)
+         
 
+        nmesh.faces = maplist
         for f in nmesh.faces:
             f.sel = 1
+
         nmesh.update()
 
+
     def _doHiddenSurfaceRemoval(self, mesh):
         """Do HSR for the given mesh.
         """
@@ -1658,11 +1905,11 @@ class Renderer:
             return
 
         if config.polygons['HSR'] == 'PAINTER':
-            print "\n\nUsing the Painter algorithm for HSR.\n"
+            print "\nUsing the Painter algorithm for HSR."
             self.__simpleDepthSort(mesh)
 
         elif config.polygons['HSR'] == 'NEWELL':
-            print "\n\nUsing the Newell's algorithm for HSR.\n"
+            print "\nUsing the Newell's algorithm for HSR."
             self.__newellDepthSort(mesh)
 
 
@@ -1955,9 +2202,6 @@ def vectorize(filename):
 
     if editmode: Window.EditMode(1) 
 
-# We use a global progress Indicator Object
-progress = None
-
 # Here the main
 if __name__ == "__main__":