vrm.py

   1 #!BPY
   2 """
   3 Name: 'VRM'
   4 Blender: 242
   5 Group: 'Render'
   6 Tooltip: 'Vector Rendering Method script'
   7 """
   8
   9 __author__ = "Antonio Ospite"
  10 __url__ = ["http://vrm.projects.blender.org"]
  11 __version__ = "0.3"
  12
  13 __bpydoc__ = """\
  14     Render the scene and save the result in vector format.
  15 """
  16
  17 # ---------------------------------------------------------------------
  18 #    Copyright (c) 2006 Antonio Ospite
  19 #
  20 #    This program is free software; you can redistribute it and/or modify
  21 #    it under the terms of the GNU General Public License as published by
  22 #    the Free Software Foundation; either version 2 of the License, or
  23 #    (at your option) any later version.
  24 #
  25 #    This program is distributed in the hope that it will be useful,
  26 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  27 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28 #    GNU General Public License for more details.
  29 #
  30 #    You should have received a copy of the GNU General Public License
  31 #    along with this program; if not, write to the Free Software
  32 #    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  33 #
  34 # ---------------------------------------------------------------------
  35 #
  36 # Additional credits:
  37 #   Thanks to Emilio Aguirre for S2flender from which I took inspirations :)
  38 #   Thanks to Nikola Radovanovic, the author of the original VRM script,
  39 #       the code you read here has been rewritten _almost_ entirely
  40 #       from scratch but Nikola gave me the idea, so I thank him publicly.
  41 #
  42 # ---------------------------------------------------------------------
  43 #
  44 # Things TODO for a next release:
  45 #   - Switch to the Mesh structure, should be considerably faster
  46 #    (partially done, but with Mesh we cannot sort faces, yet)
  47 #   - Use a better depth sorting algorithm
  48 #   - Review how selections are made (this script uses selection states of
  49 #     primitives to represent visibility infos)
  50 #   - Implement clipping of primitives and do handle object intersections.
  51 #     (for now only clipping for whole objects is supported).
  52 #   - Implement Edge Styles (silhouettes, contours, etc.) (partially done).
  53 #   - Use multiple lighting sources in color calculation
  54 #   - Implement Shading Styles? (for now we use Flat Shading).
  55 #   - Use a data structure other than Mesh to represent the 2D image?
  56 #     Think to a way to merge adjacent polygons that have the same color.
  57 #     Or a way to use paths for silhouettes and contours.
  58 #   - Add Vector Writers other that SVG.
  59 #   - Consider SMIL for animation handling instead of ECMA Script? (Firefox do
  60 #     not support SMIL for animations)
  61 #   - FIX the issue with negative scales in object tranformations!
  62 #
  63 # ---------------------------------------------------------------------
  64 #
  65 # Changelog:
  66 #
  67 #   vrm-0.3.py  -   2006-05-19
  68 #    * First release after code restucturing.
  69 #      Now the script offers a useful set of functionalities
  70 #      and it can render animations, too.
  71 #
  72 # ---------------------------------------------------------------------
  73
  74 import Blender
  75 from Blender import Scene, Object, Mesh, NMesh, Material, Lamp, Camera
  76 from Blender.Mathutils import *
  77 from math import *
  78
  79
  80 # Some global settings
  81
  82 class config:
  83     polygons = dict()
  84     polygons['SHOW'] = True
  85     polygons['SHADING'] = 'TOON'
  86     # Hidden to the user for now
  87     polygons['EXPANSION_TRICK'] = True
  88
  89     edges = dict()
  90     edges['SHOW'] = True
  91     edges['SHOW_HIDDEN'] = False
  92     edges['STYLE'] = 'SILHOUETTE'
  93     edges['WIDTH'] = 2
  94     edges['COLOR'] = [0, 0, 0]
  95
  96     output = dict()
  97     output['FORMAT'] = 'SVG'
  98     output['ANIMATION'] = False
  99     output['JOIN_OBJECTS'] = True
 100
 101
 102
 103 # ---------------------------------------------------------------------
 104 #
 105 ## Utility Mesh class
 106 #
 107 # ---------------------------------------------------------------------
 108 class MeshUtils:
 109
 110     def getEdgeAdjacentFaces(edge, mesh):
 111         """Get the faces adjacent to a given edge.
 112
 113         There can be 0, 1 or more (usually 2) faces adjacent to an edge.
 114         """
 115         adjface_list = []
 116
 117         for f in mesh.faces:
 118             if (edge.v1 in f.v) and (edge.v2 in f.v):
 119                 adjface_list.append(f)
 120
 121         return adjface_list
 122
 123     def isMeshEdge(e, mesh):
 124         """Mesh edge rule.
 125
 126         A mesh edge is visible if _any_ of its adjacent faces is selected.
 127         Note: if the edge has no adjacent faces we want to show it as well,
 128         useful for "edge only" portion of objects.
 129         """
 130
 131         adjacent_faces = MeshUtils.getEdgeAdjacentFaces(e, mesh)
 132
 133         if len(adjacent_faces) == 0:
 134             return True
 135
 136         selected_faces = [f for f in adjacent_faces if f.sel]
 137
 138         if len(selected_faces) != 0:
 139             return True
 140         else:
 141             return False
 142
 143     def isSilhouetteEdge(e, mesh):
 144         """Silhuette selection rule.
 145
 146         An edge is a silhuette edge if it is shared by two faces with
 147         different selection status or if it is a boundary edge of a selected
 148         face.
 149         """
 150
 151         adjacent_faces = MeshUtils.getEdgeAdjacentFaces(e, mesh)
 152
 153         if ((len(adjacent_faces) == 1 and adjacent_faces[0].sel == 1) or
 154             (len(adjacent_faces) == 2 and
 155                 adjacent_faces[0].sel != adjacent_faces[1].sel)
 156             ):
 157             return True
 158         else:
 159             return False
 160
 161     def toonShading(u):
 162
 163         levels = 2
 164         texels = 2*levels - 1
 165         map = [0.0] + [(i)/float(texels-1) for i in range(1, texels-1) ] + [1.0]
 166
 167         v = 1.0
 168         for i in range(0, len(map)-1):
 169             pivot = (map[i]+map[i+1])/2.0
 170             j = int(u>pivot)
 171
 172             v = map[i+j]
 173
 174             if v<map[i+1]:
 175                 return v
 176
 177         return v
 178
 179
 180     getEdgeAdjacentFaces = staticmethod(getEdgeAdjacentFaces)
 181     isMeshEdge = staticmethod(isMeshEdge)
 182     isSilhouetteEdge = staticmethod(isSilhouetteEdge)
 183     toonShading = staticmethod(toonShading)
 184
 185
 186
 187 # ---------------------------------------------------------------------
 188 #
 189 ## Projections classes
 190 #
 191 # ---------------------------------------------------------------------
 192
 193 class Projector:
 194     """Calculate the projection of an object given the camera.
 195
 196     A projector is useful to so some per-object transformation to obtain the
 197     projection of an object given the camera.
 198
 199     The main method is #doProjection# see the method description for the
 200     parameter list.
 201     """
 202
 203     def __init__(self, cameraObj, canvasRatio):
 204         """Calculate the projection matrix.
 205
 206         The projection matrix depends, in this case, on the camera settings.
 207         TAKE CARE: This projector expects vertices in World Coordinates!
 208         """
 209
 210         camera = cameraObj.getData()
 211
 212         aspect = float(canvasRatio[0])/float(canvasRatio[1])
 213         near = camera.clipStart
 214         far = camera.clipEnd
 215
 216         scale = float(camera.scale)
 217
 218         fovy = atan(0.5/aspect/(camera.lens/32))
 219         fovy = fovy * 360.0/pi
 220
 221         # What projection do we want?
 222         if camera.type:
 223             #mP = self._calcOrthoMatrix(fovy, aspect, near, far, 17) #camera.scale)
 224             mP = self._calcOrthoMatrix(fovy, aspect, near, far, scale)
 225         else:
 226             mP = self._calcPerspectiveMatrix(fovy, aspect, near, far)
 227
 228         # View transformation
 229         cam = Matrix(cameraObj.getInverseMatrix())
 230         cam.transpose()
 231
 232         mP = mP * cam
 233
 234         self.projectionMatrix = mP
 235
 236     ##
 237     # Public methods
 238     #
 239
 240     def doProjection(self, v):
 241         """Project the point on the view plane.
 242
 243         Given a vertex calculate the projection using the current projection
 244         matrix.
 245         """
 246
 247         # Note that we have to work on the vertex using homogeneous coordinates
 248         p = self.projectionMatrix * Vector(v).resize4D()
 249
 250         if p[3]>0:
 251             p[0] = p[0]/p[3]
 252             p[1] = p[1]/p[3]
 253
 254         # restore the size
 255         p[3] = 1.0
 256         p.resize3D()
 257
 258         return p
 259
 260     ##
 261     # Private methods
 262     #
 263
 264     def _calcPerspectiveMatrix(self, fovy, aspect, near, far):
 265         """Return a perspective projection matrix.
 266         """
 267
 268         top = near * tan(fovy * pi / 360.0)
 269         bottom = -top
 270         left = bottom*aspect
 271         right= top*aspect
 272         x = (2.0 * near) / (right-left)
 273         y = (2.0 * near) / (top-bottom)
 274         a = (right+left) / (right-left)
 275         b = (top+bottom) / (top - bottom)
 276         c = - ((far+near) / (far-near))
 277         d = - ((2*far*near)/(far-near))
 278
 279         m = Matrix(
 280                 [x,   0.0,    a,    0.0],
 281                 [0.0,   y,    b,    0.0],
 282                 [0.0, 0.0,    c,      d],
 283                 [0.0, 0.0, -1.0,    0.0])
 284
 285         return m
 286
 287     def _calcOrthoMatrix(self, fovy, aspect , near, far, scale):
 288         """Return an orthogonal projection matrix.
 289         """
 290
 291         # The 11 in the formula was found emiprically
 292         top = near * tan(fovy * pi / 360.0) * (scale * 11)
 293         bottom = -top
 294         left = bottom * aspect
 295         right= top * aspect
 296         rl = right-left
 297         tb = top-bottom
 298         fn = near-far
 299         tx = -((right+left)/rl)
 300         ty = -((top+bottom)/tb)
 301         tz = ((far+near)/fn)
 302
 303         m = Matrix(
 304                 [2.0/rl, 0.0,    0.0,     tx],
 305                 [0.0,    2.0/tb, 0.0,     ty],
 306                 [0.0,    0.0,    2.0/fn,  tz],
 307                 [0.0,    0.0,    0.0,    1.0])
 308
 309         return m
 310
 311
 312
 313 # ---------------------------------------------------------------------
 314 #
 315 ## 2D Object representation class
 316 #
 317 # ---------------------------------------------------------------------
 318
 319 # TODO: a class to represent the needed properties of a 2D vector image
 320 # For now just using a [N]Mesh structure.
 321
 322
 323 # ---------------------------------------------------------------------
 324 #
 325 ## Vector Drawing Classes
 326 #
 327 # ---------------------------------------------------------------------
 328
 329 ## A generic Writer
 330
 331 class VectorWriter:
 332     """
 333     A class for printing output in a vectorial format.
 334
 335     Given a 2D representation of the 3D scene the class is responsible to
 336     write it is a vector format.
 337
 338     Every subclasses of VectorWriter must have at last the following public
 339     methods:
 340         - open(self)
 341         - close(self)
 342         - printCanvas(self, scene,
 343             doPrintPolygons=True, doPrintEdges=False, showHiddenEdges=False):
 344     """
 345
 346     def __init__(self, fileName):
 347         """Set the output file name and other properties"""
 348
 349         self.outputFileName = fileName
 350         self.file = None
 351
 352         context = Scene.GetCurrent().getRenderingContext()
 353         self.canvasSize = ( context.imageSizeX(), context.imageSizeY() )
 354
 355         self.startFrame = 1
 356         self.endFrame = 1
 357         self.animation = False
 358
 359
 360     ##
 361     # Public Methods
 362     #
 363
 364     def open(self, startFrame=1, endFrame=1):
 365         if startFrame != endFrame:
 366             self.startFrame = startFrame
 367             self.endFrame = endFrame
 368             self.animation = True
 369
 370         self.file = open(self.outputFileName, "w")
 371         print "Outputting to: ", self.outputFileName
 372
 373         return
 374
 375     def close(self):
 376         self.file.close()
 377         return
 378
 379     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
 380             showHiddenEdges=False):
 381         """This is the interface for the needed printing routine.
 382         """
 383         return
 384
 385
 386 ## SVG Writer
 387
 388 class SVGVectorWriter(VectorWriter):
 389     """A concrete class for writing SVG output.
 390     """
 391
 392     def __init__(self, fileName):
 393         """Simply call the parent Contructor.
 394         """
 395         VectorWriter.__init__(self, fileName)
 396
 397
 398     ##
 399     # Public Methods
 400     #
 401
 402     def open(self, startFrame=1, endFrame=1):
 403         """Do some initialization operations.
 404         """
 405         VectorWriter.open(self, startFrame, endFrame)
 406         self._printHeader()
 407
 408     def close(self):
 409         """Do some finalization operation.
 410         """
 411         self._printFooter()
 412
 413         # remember to call the close method of the parent
 414         VectorWriter.close(self)
 415
 416
 417     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
 418             showHiddenEdges=False):
 419         """Convert the scene representation to SVG.
 420         """
 421
 422         Objects = scene.getChildren()
 423
 424         context = scene.getRenderingContext()
 425         framenumber = context.currentFrame()
 426
 427         if self.animation:
 428             framestyle = "display:none"
 429         else:
 430             framestyle = "display:block"
 431
 432         # Assign an id to this group so we can set properties on it using DOM
 433         self.file.write("<g id=\"frame%d\" style=\"%s\">\n" %
 434                 (framenumber, framestyle) )
 435
 436
 437         for obj in Objects:
 438
 439             if(obj.getType() != 'Mesh'):
 440                 continue
 441
 442             self.file.write("<g id=\"%s\">\n" % obj.getName())
 443
 444             mesh = obj.getData(mesh=1)
 445
 446             if doPrintPolygons:
 447                 self._printPolygons(mesh)
 448
 449             if doPrintEdges:
 450                 self._printEdges(mesh, showHiddenEdges)
 451
 452             self.file.write("</g>\n")
 453
 454         self.file.write("</g>\n")
 455
 456
 457     ##
 458     # Private Methods
 459     #
 460
 461     def _calcCanvasCoord(self, v):
 462         """Convert vertex in scene coordinates to canvas coordinates.
 463         """
 464
 465         pt = Vector([0, 0, 0])
 466
 467         mW = float(self.canvasSize[0])/2.0
 468         mH = float(self.canvasSize[1])/2.0
 469
 470         # rescale to canvas size
 471         pt[0] = v.co[0]*mW + mW
 472         pt[1] = v.co[1]*mH + mH
 473         pt[2] = v.co[2]
 474
 475         # For now we want (0,0) in the top-left corner of the canvas.
 476         # Mirror and translate along y
 477         pt[1] *= -1
 478         pt[1] += self.canvasSize[1]
 479
 480         return pt
 481
 482     def _printHeader(self):
 483         """Print SVG header."""
 484
 485         self.file.write("<?xml version=\"1.0\"?>\n")
 486         self.file.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n")
 487         self.file.write("\t\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n")
 488         self.file.write("<svg version=\"1.1\"\n")
 489         self.file.write("\txmlns=\"http://www.w3.org/2000/svg\"\n")
 490         self.file.write("\twidth=\"%d\" height=\"%d\" streamable=\"true\">\n\n" %
 491                 self.canvasSize)
 492
 493         if self.animation:
 494
 495             self.file.write("""\n<script><![CDATA[
 496             globalStartFrame=%d;
 497             globalEndFrame=%d;
 498
 499             /* FIXME: Use 1000 as interval as lower values gives problems */
 500             timerID = setInterval("NextFrame()", 1000);
 501             globalFrameCounter=%d;
 502
 503             function NextFrame()
 504             {
 505               currentElement  = document.getElementById('frame'+globalFrameCounter)
 506               previousElement = document.getElementById('frame'+(globalFrameCounter-1))
 507
 508               if (!currentElement)
 509               {
 510                 return;
 511               }
 512
 513               if (globalFrameCounter > globalEndFrame)
 514               {
 515                 clearInterval(timerID)
 516               }
 517               else
 518               {
 519                 if(previousElement)
 520                 {
 521                     previousElement.style.display="none";
 522                 }
 523                 currentElement.style.display="block";
 524                 globalFrameCounter++;
 525               }
 526             }
 527             \n]]></script>\n
 528             \n""" % (self.startFrame, self.endFrame, self.startFrame) )
 529
 530     def _printFooter(self):
 531         """Print the SVG footer."""
 532
 533         self.file.write("\n</svg>\n")
 534
 535     def _printPolygons(self, mesh):
 536         """Print the selected (visible) polygons.
 537         """
 538
 539         if len(mesh.faces) == 0:
 540             return
 541
 542         self.file.write("<g>\n")
 543
 544         for face in mesh.faces:
 545             if not face.sel:
 546                continue
 547
 548             self.file.write("<polygon points=\"")
 549
 550             for v in face:
 551                 p = self._calcCanvasCoord(v)
 552                 self.file.write("%g,%g " % (p[0], p[1]))
 553
 554             # get rid of the last blank space, just cosmetics here.
 555             self.file.seek(-1, 1)
 556             self.file.write("\"\n")
 557
 558             # take as face color the first vertex color
 559             # TODO: the average of vetrex colors?
 560             if face.col:
 561                 fcol = face.col[0]
 562                 color = [fcol.r, fcol.g, fcol.b, fcol.a]
 563             else:
 564                 color = [255, 255, 255, 255]
 565
 566             # Convert the color to the #RRGGBB form
 567             str_col = "#%02X%02X%02X" % (color[0], color[1], color[2])
 568
 569             # use the stroke property to alleviate the "adjacent edges" problem,
 570             # we simulate polygon expansion using borders,
 571             # see http://www.antigrain.com/svg/index.html for more info
 572             stroke_width = 0.5
 573
 574             # Handle transparent polygons
 575             opacity_string = ""
 576             if color[3] != 255:
 577                 opacity = float(color[3])/255.0
 578                 opacity_string = " fill-opacity: %g; stroke-opacity: %g; opacity: 1;" % (opacity, opacity)
 579
 580             self.file.write("\tstyle=\"fill:" + str_col + ";")
 581             self.file.write(opacity_string)
 582             if config.polygons['EXPANSION_TRICK']:
 583                 self.file.write(" stroke:" + str_col + ";")
 584                 self.file.write(" stroke-width:" + str(stroke_width) + ";\n")
 585                 self.file.write(" stroke-linecap:round;stroke-linejoin:round")
 586             self.file.write("\"/>\n")
 587
 588         self.file.write("</g>\n")
 589
 590     def _printEdges(self, mesh, showHiddenEdges=False):
 591         """Print the wireframe using mesh edges.
 592         """
 593
 594         stroke_width = config.edges['WIDTH']
 595         stroke_col = config.edges['COLOR']
 596
 597         self.file.write("<g>\n")
 598
 599         for e in mesh.edges:
 600
 601             hidden_stroke_style = ""
 602
 603             if e.sel == 0:
 604                 if showHiddenEdges == False:
 605                     continue
 606                 else:
 607                     hidden_stroke_style = ";\n stroke-dasharray:3, 3"
 608
 609             p1 = self._calcCanvasCoord(e.v1)
 610             p2 = self._calcCanvasCoord(e.v2)
 611
 612             self.file.write("<line x1=\"%g\" y1=\"%g\" x2=\"%g\" y2=\"%g\"\n"
 613                     % ( p1[0], p1[1], p2[0], p2[1] ) )
 614             self.file.write(" style=\"stroke:rgb("+str(stroke_col[0])+","+str(stroke_col[1])+","+str(stroke_col[2])+");")
 615             self.file.write(" stroke-width:"+str(stroke_width)+";\n")
 616             self.file.write(" stroke-linecap:round;stroke-linejoin:round")
 617             self.file.write(hidden_stroke_style)
 618             self.file.write("\"/>\n")
 619
 620         self.file.write("</g>\n")
 621
 622
 623
 624 # ---------------------------------------------------------------------
 625 #
 626 ## Rendering Classes
 627 #
 628 # ---------------------------------------------------------------------
 629
 630 # A dictionary to collect different shading style methods
 631 shadingStyles = dict()
 632 shadingStyles['FLAT'] = None
 633 shadingStyles['TOON'] = None
 634
 635 # A dictionary to collect different edge style methods
 636 edgeStyles = dict()
 637 edgeStyles['MESH'] = MeshUtils.isMeshEdge
 638 edgeStyles['SILHOUETTE'] = MeshUtils.isSilhouetteEdge
 639
 640 # A dictionary to collect the supported output formats
 641 outputWriters = dict()
 642 outputWriters['SVG'] = SVGVectorWriter
 643
 644
 645 class Renderer:
 646     """Render a scene viewed from a given camera.
 647
 648     This class is responsible of the rendering process, transformation and
 649     projection of the objects in the scene are invoked by the renderer.
 650
 651     The rendering is done using the active camera for the current scene.
 652     """
 653
 654     def __init__(self):
 655         """Make the rendering process only for the current scene by default.
 656
 657         We will work on a copy of the scene, be sure that the current scene do
 658         not get modified in any way.
 659         """
 660
 661         # Render the current Scene, this should be a READ-ONLY property
 662         self._SCENE = Scene.GetCurrent()
 663
 664         # Use the aspect ratio of the scene rendering context
 665         context = self._SCENE.getRenderingContext()
 666
 667         aspect_ratio = float(context.imageSizeX())/float(context.imageSizeY())
 668         self.canvasRatio = (float(context.aspectRatioX())*aspect_ratio,
 669                             float(context.aspectRatioY())
 670                             )
 671
 672         # Render from the currently active camera
 673         self.cameraObj = self._SCENE.getCurrentCamera()
 674
 675         # Get a projector for this camera.
 676         # NOTE: the projector wants object in world coordinates,
 677         # so we should remember to apply modelview transformations
 678         # _before_ we do projection transformations.
 679         self.proj = Projector(self.cameraObj, self.canvasRatio)
 680
 681         # Get the list of lighting sources
 682         obj_lst = self._SCENE.getChildren()
 683         self.lights = [ o for o in obj_lst if o.getType() == 'Lamp']
 684
 685         # When there are no lights we use a default lighting source
 686         # that have the same position of the camera
 687         if len(self.lights) == 0:
 688             l = Lamp.New('Lamp')
 689             lobj = Object.New('Lamp')
 690             lobj.loc = self.cameraObj.loc
 691             lobj.link(l)
 692             self.lights.append(lobj)
 693
 694
 695     ##
 696     # Public Methods
 697     #
 698
 699     def doRendering(self, outputWriter, animation=False):
 700         """Render picture or animation and write it out.
 701
 702         The parameters are:
 703             - a Vector writer object that will be used to output the result.
 704             - a flag to tell if we want to render an animation or only the
 705               current frame.
 706         """
 707
 708         context = self._SCENE.getRenderingContext()
 709         origCurrentFrame = context.currentFrame()
 710
 711         # Handle the animation case
 712         if not animation:
 713             startFrame = origCurrentFrame
 714             endFrame = startFrame
 715             outputWriter.open()
 716         else:
 717             startFrame = context.startFrame()
 718             endFrame = context.endFrame()
 719             outputWriter.open(startFrame, endFrame)
 720
 721         # Do the rendering process frame by frame
 722         print "Start Rendering!"
 723         for f in range(startFrame, endFrame+1):
 724             context.currentFrame(f)
 725
 726             # Use some temporary workspace, a full copy of the scene
 727             inputScene = self._SCENE.copy(2)
 728
 729             try:
 730                 renderedScene = self.doRenderScene(inputScene)
 731             except :
 732                 print "There was an error! Aborting."
 733                 import traceback
 734                 print traceback.print_exc()
 735
 736                 self._SCENE.makeCurrent()
 737                 Scene.unlink(inputScene)
 738                 del inputScene
 739                 return
 740
 741             outputWriter.printCanvas(renderedScene,
 742                     doPrintPolygons = config.polygons['SHOW'],
 743                     doPrintEdges    = config.edges['SHOW'],
 744                     showHiddenEdges = config.edges['SHOW_HIDDEN'])
 745
 746             # clear the rendered scene
 747             self._SCENE.makeCurrent()
 748             Scene.unlink(renderedScene)
 749             del renderedScene
 750
 751         outputWriter.close()
 752         print "Done!"
 753         context.currentFrame(origCurrentFrame)
 754
 755
 756     def doRenderScene(self, workScene):
 757         """Control the rendering process.
 758
 759         Here we control the entire rendering process invoking the operation
 760         needed to transform and project the 3D scene in two dimensions.
 761         """
 762
 763         # global processing of the scene
 764
 765         self._doConvertGeometricObjToMesh(workScene)
 766
 767         self._doSceneClipping(workScene)
 768
 769         if config.output['JOIN_OBJECTS']:
 770             self._joinMeshObjectsInScene(workScene)
 771
 772         self._doSceneDepthSorting(workScene)
 773
 774         # Per object activities
 775
 776         Objects = workScene.getChildren()
 777         for obj in Objects:
 778
 779             if obj.getType() != 'Mesh':
 780                 print "Only Mesh supported! - Skipping type:", obj.getType()
 781                 continue
 782
 783             print "Rendering: ", obj.getName()
 784
 785             mesh = obj.getData(mesh=1)
 786
 787             self._doModelToWorldCoordinates(mesh, obj.matrix)
 788
 789             self._doObjectDepthSorting(mesh)
 790
 791             self._doBackFaceCulling(mesh)
 792
 793             self._doColorAndLighting(mesh)
 794
 795             self._doEdgesStyle(mesh, edgeStyles[config.edges['STYLE']])
 796
 797             self._doProjection(mesh, self.proj)
 798
 799             # Update the object data, important! :)
 800             mesh.update()
 801
 802         return workScene
 803
 804
 805     ##
 806     # Private Methods
 807     #
 808
 809     # Utility methods
 810
 811     def _getObjPosition(self, obj):
 812         """Return the obj position in World coordinates.
 813         """
 814         return obj.matrix.translationPart()
 815
 816     def _cameraViewDirection(self):
 817         """Get the View Direction form the camera matrix.
 818         """
 819         return Vector(self.cameraObj.matrix[2]).resize3D()
 820
 821
 822     # Faces methods
 823
 824     def _isFaceVisible(self, face):
 825         """Determine if a face of an object is visible from the current camera.
 826
 827         The view vector is calculated from the camera location and one of the
 828         vertices of the face (expressed in World coordinates, after applying
 829         modelview transformations).
 830
 831         After those transformations we determine if a face is visible by
 832         computing the angle between the face normal and the view vector, this
 833         angle has to be between -90 and 90 degrees for the face to be visible.
 834         This corresponds somehow to the dot product between the two, if it
 835         results > 0 then the face is visible.
 836
 837         There is no need to normalize those vectors since we are only interested in
 838         the sign of the cross product and not in the product value.
 839
 840         NOTE: here we assume the face vertices are in WorldCoordinates, so
 841         please transform the object _before_ doing the test.
 842         """
 843
 844         normal = Vector(face.no)
 845         camPos = self._getObjPosition(self.cameraObj)
 846         view_vect = None
 847
 848         # View Vector in orthographics projections is the view Direction of
 849         # the camera
 850         if self.cameraObj.data.getType() == 1:
 851             view_vect = self._cameraViewDirection()
 852
 853         # View vector in perspective projections can be considered as
 854         # the difference between the camera position and one point of
 855         # the face, we choose the farthest point from the camera.
 856         if self.cameraObj.data.getType() == 0:
 857             vv = max( [ ((camPos - Vector(v.co)).length, (camPos - Vector(v.co))) for v in face] )
 858             view_vect = vv[1]
 859
 860         # if d > 0 the face is visible from the camera
 861         d = view_vect * normal
 862
 863         if d > 0:
 864             return True
 865         else:
 866             return False
 867
 868
 869     # Scene methods
 870
 871     def _doConvertGeometricObjToMesh(self, scene):
 872         """Convert all "geometric" objects to mesh ones.
 873         """
 874         geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text']
 875
 876         Objects = scene.getChildren()
 877         objList = [ o for o in Objects if o.getType() in geometricObjTypes ]
 878         for obj in objList:
 879             old_obj = obj
 880             obj = self._convertToRawMeshObj(obj)
 881             scene.link(obj)
 882             scene.unlink(old_obj)
 883
 884
 885             # XXX Workaround for Text and Curve which have some normals
 886             # inverted when they are converted to Mesh, REMOVE that when
 887             # blender will fix that!!
 888             if old_obj.getType() in ['Curve', 'Text']:
 889                 me = obj.getData(mesh=1)
 890                 for f in me.faces: f.sel = 1;
 891                 for v in me.verts: v.sel = 1;
 892                 me.remDoubles(0)
 893                 me.triangleToQuad()
 894                 me.recalcNormals()
 895                 me.update()
 896
 897     def _doSceneClipping(self, scene):
 898         """Clip objects against the View Frustum.
 899
 900         For now clip away only objects according to their center position.
 901         """
 902
 903         cpos = self._getObjPosition(self.cameraObj)
 904         view_vect = self._cameraViewDirection()
 905
 906         near = self.cameraObj.data.clipStart
 907         far  = self.cameraObj.data.clipEnd
 908
 909         aspect = float(self.canvasRatio[0])/float(self.canvasRatio[1])
 910         fovy = atan(0.5/aspect/(self.cameraObj.data.lens/32))
 911         fovy = fovy * 360.0/pi
 912
 913         Objects = scene.getChildren()
 914         for o in Objects:
 915             if o.getType() != 'Mesh': continue;
 916
 917             obj_vect = Vector(cpos) - self._getObjPosition(o)
 918
 919             d = obj_vect*view_vect
 920             theta = AngleBetweenVecs(obj_vect, view_vect)
 921
 922             # if the object is outside the view frustum, clip it away
 923             if (d < near) or (d > far) or (theta > fovy):
 924                 scene.unlink(o)
 925
 926     def _doSceneDepthSorting(self, scene):
 927         """Sort objects in the scene.
 928
 929         The object sorting is done accordingly to the object centers.
 930         """
 931
 932         c = self._getObjPosition(self.cameraObj)
 933
 934         by_center_pos = (lambda o1, o2:
 935                 (o1.getType() == 'Mesh' and o2.getType() == 'Mesh') and
 936                 cmp((self._getObjPosition(o1) - Vector(c)).length,
 937                     (self._getObjPosition(o2) - Vector(c)).length)
 938             )
 939
 940         # TODO: implement sorting by bounding box, if obj1.bb is inside obj2.bb,
 941         # then ob1 goes farther than obj2, useful when obj2 has holes
 942         by_bbox = None
 943
 944         Objects = scene.getChildren()
 945         Objects.sort(by_center_pos)
 946
 947         # update the scene
 948         for o in Objects:
 949             scene.unlink(o)
 950             scene.link(o)
 951
 952     def _joinMeshObjectsInScene(self, scene):
 953         """Merge all the Mesh Objects in a scene into a single Mesh Object.
 954         """
 955
 956         if Blender.mode == 'background':
 957             print "\nWARNING! Joining objects not supported in background mode!\n"
 958             return
 959
 960         oList = [o for o in scene.getChildren() if o.getType()=='Mesh']
 961
 962         # FIXME: Object.join() do not work if the list contains 1 object
 963         if len(oList) == 1:
 964             return
 965
 966         mesh = Mesh.New('BigOne')
 967         bigObj = Object.New('Mesh', 'BigOne')
 968         bigObj.link(mesh)
 969
 970         scene.link(bigObj)
 971
 972         try:
 973             bigObj.join(oList)
 974         except RuntimeError:
 975             print "Can't Join Objects"
 976             scene.unlink(bigObj)
 977             return
 978         except TypeError:
 979             print "Objects Type error?"
 980
 981         for o in oList:
 982             scene.unlink(o)
 983
 984         scene.update()
 985
 986
 987     # Per object methods
 988
 989     def _convertToRawMeshObj(self, object):
 990         """Convert geometry based object to a mesh object.
 991         """
 992         me = Mesh.New('RawMesh_'+object.name)
 993         me.getFromObject(object.name)
 994
 995         newObject = Object.New('Mesh', 'RawMesh_'+object.name)
 996         newObject.link(me)
 997
 998         # If the object has no materials set a default material
 999         if not me.materials:
1000             me.materials = [Material.New()]
1001             #for f in me.faces: f.mat = 0
1002
1003         newObject.setMatrix(object.getMatrix())
1004
1005         return newObject
1006
1007     def _doModelToWorldCoordinates(self, mesh, matrix):
1008         """Transform object coordinates to world coordinates.
1009
1010         This step is done simply applying to the object its tranformation
1011         matrix and recalculating its normals.
1012         """
1013         # XXX FIXME: blender do not transform normals in the right way when
1014         # there are negative scale values
1015         if matrix[0][0] < 0 or matrix[1][1] < 0 or matrix[2][2] < 0:
1016             print "WARNING: Negative scales, expect incorrect results!"
1017
1018         mesh.transform(matrix, True)
1019
1020     def _doObjectDepthSorting(self, mesh):
1021         """Sort faces in an object.
1022
1023         The faces in the object are sorted following the distance of the
1024         vertices from the camera position.
1025         """
1026         if len(mesh.faces) == 0:
1027             return
1028
1029         c = self._getObjPosition(self.cameraObj)
1030
1031         # hackish sorting of faces
1032
1033         # Sort faces according to the max distance from the camera
1034         by_max_vert_dist = (lambda f1, f2:
1035                 cmp(max([(Vector(v.co)-Vector(c)).length for v in f1]),
1036                     max([(Vector(v.co)-Vector(c)).length for v in f2])))
1037
1038         # Sort faces according to the min distance from the camera
1039         by_min_vert_dist = (lambda f1, f2:
1040                 cmp(min([(Vector(v.co)-Vector(c)).length for v in f1]),
1041                     min([(Vector(v.co)-Vector(c)).length for v in f2])))
1042
1043         # Sort faces according to the avg distance from the camera
1044         by_avg_vert_dist = (lambda f1, f2:
1045                 cmp(sum([(Vector(v.co)-Vector(c)).length for v in f1])/len(f1),
1046                     sum([(Vector(v.co)-Vector(c)).length for v in f2])/len(f2)))
1047
1048
1049         # FIXME: using NMesh to sort faces. We should avoid that!
1050         nmesh = NMesh.GetRaw(mesh.name)
1051         nmesh.faces.sort(by_max_vert_dist)
1052         nmesh.faces.reverse()
1053
1054         mesh.faces.delete(1, range(0, len(mesh.faces)))
1055
1056         for i,f in enumerate(nmesh.faces):
1057             fv = [v.index for v in f.v]
1058             mesh.faces.extend(fv)
1059             mesh.faces[i].mat = f.mat
1060
1061
1062     def _doBackFaceCulling(self, mesh):
1063         """Simple Backface Culling routine.
1064
1065         At this level we simply do a visibility test face by face and then
1066         select the vertices belonging to visible faces.
1067         """
1068
1069         # Select all vertices, so edges can be displayed even if there are no
1070         # faces
1071         for v in mesh.verts:
1072             v.sel = 1
1073
1074         Mesh.Mode(Mesh.SelectModes['FACE'])
1075         # Loop on faces
1076         for f in mesh.faces:
1077             f.sel = 0
1078             if self._isFaceVisible(f):
1079                 f.sel = 1
1080
1081     def _doColorAndLighting(self, mesh):
1082         """Apply an Illumination ans shading model to the object.
1083
1084         The model used is the Phong one, it may be inefficient,
1085         but I'm just learning about rendering and starting from Phong seemed
1086         the most natural way.
1087         """
1088
1089         # If the mesh has vertex colors already, use them,
1090         # otherwise turn them on and do some calculations
1091         if mesh.vertexColors:
1092             return
1093         mesh.vertexColors = 1
1094
1095         materials = mesh.materials
1096
1097         # TODO: use multiple lighting sources
1098         light_obj = self.lights[0]
1099         light_pos = self._getObjPosition(light_obj)
1100         light = light_obj.data
1101
1102         camPos = self._getObjPosition(self.cameraObj)
1103
1104         # We do per-face color calculation (FLAT Shading), we can easily turn
1105         # to a per-vertex calculation if we want to implement some shading
1106         # technique. For an example see:
1107         # http://www.miralab.unige.ch/papers/368.pdf
1108         for f in mesh.faces:
1109             if not f.sel:
1110                 continue
1111
1112             mat = None
1113             if materials:
1114                 mat = materials[f.mat]
1115
1116             # A new default material
1117             if mat == None:
1118                 mat = Material.New('defMat')
1119
1120             L = Vector(light_pos).normalize()
1121
1122             V = (Vector(camPos) - Vector(f.cent)).normalize()
1123
1124             N = Vector(f.no).normalize()
1125
1126             R = 2 * (N*L) * N - L
1127
1128             # TODO: Attenuation factor (not used for now)
1129             a0 = 1.0; a1 = 0.0; a2 = 1.0
1130             d = (Vector(f.v[0].co) - Vector(light_pos)).length
1131             fd = min(1, 1.0/(a0 + a1*d + a2*(d*d)))
1132
1133             # Ambient component
1134             Ia = 1.0
1135             ka = mat.getAmb() * Vector([0.1, 0.1, 0.1])
1136             Iamb = Ia * ka
1137
1138             # Diffuse component (add light.col for kd)
1139             kd = mat.getRef() * Vector(mat.getRGBCol())
1140             Ip = light.getEnergy()
1141
1142             if config.polygons['SHADING'] == 'FLAT':
1143                 Idiff = Ip * kd * (N*L)
1144             elif config.polygons['SHADING'] == 'TOON':
1145                 Idiff = Ip * kd * MeshUtils.toonShading(N*L)
1146
1147             # Specular component
1148             ks = mat.getSpec() * Vector(mat.getSpecCol())
1149             ns = mat.getHardness()
1150             Ispec = Ip * ks * pow((V*R), ns)
1151
1152             # Emissive component
1153             ki = Vector([mat.getEmit()]*3)
1154
1155             I = ki + Iamb + (Idiff + Ispec)
1156
1157
1158             # Set Alpha component
1159             I = list(I)
1160             I.append(mat.getAlpha())
1161
1162             # Clamp I values between 0 and 1
1163             I = [ min(c, 1) for c in I]
1164             I = [ max(0, c) for c in I]
1165
1166             # Convert to a value between 0 and 255
1167             tmp_col = [ int(c * 255.0) for c in I]
1168
1169             for c in f.col:
1170                 c.r = tmp_col[0]
1171                 c.g = tmp_col[1]
1172                 c.b = tmp_col[2]
1173                 c.a = tmp_col[3]
1174
1175     def _doEdgesStyle(self, mesh, edgestyleSelect):
1176         """Process Mesh Edges accroding to a given selection style.
1177
1178         Examples of algorithms:
1179
1180         Contours:
1181             given an edge if its adjacent faces have the same normal (that is
1182             they are complanar), than deselect it.
1183
1184         Silhouettes:
1185             given an edge if one its adjacent faces is frontfacing and the
1186             other is backfacing, than select it, else deselect.
1187         """
1188
1189         Mesh.Mode(Mesh.SelectModes['EDGE'])
1190
1191         for e in mesh.edges:
1192
1193             e.sel = 0
1194             if edgestyleSelect(e, mesh):
1195                 e.sel = 1
1196
1197     def _doProjection(self, mesh, projector):
1198         """Calculate the Projection for the object.
1199         """
1200         # TODO: maybe using the object.transform() can be faster?
1201
1202         for v in mesh.verts:
1203             p = projector.doProjection(v.co)
1204             v.co[0] = p[0]
1205             v.co[1] = p[1]
1206             v.co[2] = p[2]
1207
1208
1209
1210 # ---------------------------------------------------------------------
1211 #
1212 ## GUI Class and Main Program
1213 #
1214 # ---------------------------------------------------------------------
1215
1216
1217 from Blender import BGL, Draw
1218 from Blender.BGL import *
1219
1220 class GUI:
1221
1222     def _init():
1223
1224         # Output Format menu
1225         output_format = config.output['FORMAT']
1226         default_value = outputWriters.keys().index(output_format)+1
1227         GUI.outFormatMenu = Draw.Create(default_value)
1228         GUI.evtOutFormatMenu = 0
1229
1230         # Animation toggle button
1231         GUI.animToggle = Draw.Create(config.output['ANIMATION'])
1232         GUI.evtAnimToggle = 1
1233
1234         # Join Objects toggle button
1235         GUI.joinObjsToggle = Draw.Create(config.output['JOIN_OBJECTS'])
1236         GUI.evtJoinObjsToggle = 2
1237
1238         # Render filled polygons
1239         GUI.polygonsToggle = Draw.Create(config.polygons['SHOW'])
1240
1241         # Shading Style menu
1242         shading_style = config.polygons['SHADING']
1243         default_value = shadingStyles.keys().index(shading_style)+1
1244         GUI.shadingStyleMenu = Draw.Create(default_value)
1245         GUI.evtShadingStyleMenu = 21
1246
1247         GUI.evtPolygonsToggle = 3
1248         # We hide the config.polygons['EXPANSION_TRICK'], for now
1249
1250         # Render polygon edges
1251         GUI.showEdgesToggle = Draw.Create(config.edges['SHOW'])
1252         GUI.evtShowEdgesToggle = 4
1253
1254         # Render hidden edges
1255         GUI.showHiddenEdgesToggle = Draw.Create(config.edges['SHOW_HIDDEN'])
1256         GUI.evtShowHiddenEdgesToggle = 5
1257
1258         # Edge Style menu
1259         edge_style = config.edges['STYLE']
1260         default_value = edgeStyles.keys().index(edge_style)+1
1261         GUI.edgeStyleMenu = Draw.Create(default_value)
1262         GUI.evtEdgeStyleMenu = 6
1263
1264         # Edge Width slider
1265         GUI.edgeWidthSlider = Draw.Create(config.edges['WIDTH'])
1266         GUI.evtEdgeWidthSlider = 7
1267
1268         # Edge Color Picker
1269         c = config.edges['COLOR']
1270         GUI.edgeColorPicker = Draw.Create(c[0]/255.0, c[1]/255.0, c[2]/255.0)
1271         GUI.evtEdgeColorPicker = 71
1272
1273         # Render Button
1274         GUI.evtRenderButton = 8
1275
1276         # Exit Button
1277         GUI.evtExitButton = 9
1278
1279     def draw():
1280
1281         # initialize static members
1282         GUI._init()
1283
1284         glClear(GL_COLOR_BUFFER_BIT)
1285         glColor3f(0.0, 0.0, 0.0)
1286         glRasterPos2i(10, 350)
1287         Draw.Text("VRM: Vector Rendering Method script.")
1288         glRasterPos2i(10, 335)
1289         Draw.Text("Press Q or ESC to quit.")
1290
1291         # Build the output format menu
1292         glRasterPos2i(10, 310)
1293         Draw.Text("Select the output Format:")
1294         outMenuStruct = "Output Format %t"
1295         for t in outputWriters.keys():
1296            outMenuStruct = outMenuStruct + "|%s" % t
1297         GUI.outFormatMenu = Draw.Menu(outMenuStruct, GUI.evtOutFormatMenu,
1298                 10, 285, 160, 18, GUI.outFormatMenu.val, "Choose the Output Format")
1299
1300         # Animation toggle
1301         GUI.animToggle = Draw.Toggle("Animation", GUI.evtAnimToggle,
1302                 10, 260, 160, 18, GUI.animToggle.val,
1303                 "Toggle rendering of animations")
1304
1305         # Join Objects toggle
1306         GUI.joinObjsToggle = Draw.Toggle("Join objects", GUI.evtJoinObjsToggle,
1307                 10, 235, 160, 18, GUI.joinObjsToggle.val,
1308                 "Join objects in the rendered file")
1309
1310         # Render Button
1311         Draw.Button("Render", GUI.evtRenderButton, 10, 210-25, 75, 25+18,
1312                 "Start Rendering")
1313         Draw.Button("Exit", GUI.evtExitButton, 95, 210-25, 75, 25+18, "Exit!")
1314
1315         # Rendering Styles
1316         glRasterPos2i(200, 310)
1317         Draw.Text("Rendering Style:")
1318
1319         # Render Polygons
1320         GUI.polygonsToggle = Draw.Toggle("Filled Polygons", GUI.evtPolygonsToggle,
1321                 200, 285, 160, 18, GUI.polygonsToggle.val,
1322                 "Render filled polygons")
1323
1324         if GUI.polygonsToggle.val == 1:
1325
1326             # Polygon Shading Style
1327             shadingStyleMenuStruct = "Shading Style %t"
1328             for t in shadingStyles.keys():
1329                 shadingStyleMenuStruct = shadingStyleMenuStruct + "|%s" % t.lower()
1330             GUI.shadingStyleMenu = Draw.Menu(shadingStyleMenuStruct, GUI.evtShadingStyleMenu,
1331                     200, 260, 160, 18, GUI.shadingStyleMenu.val,
1332                     "Choose the shading style")
1333
1334
1335         # Render Edges
1336         GUI.showEdgesToggle = Draw.Toggle("Show Edges", GUI.evtShowEdgesToggle,
1337                 200, 235, 160, 18, GUI.showEdgesToggle.val,
1338                 "Render polygon edges")
1339
1340         if GUI.showEdgesToggle.val == 1:
1341
1342             # Edge Style
1343             edgeStyleMenuStruct = "Edge Style %t"
1344             for t in edgeStyles.keys():
1345                 edgeStyleMenuStruct = edgeStyleMenuStruct + "|%s" % t.lower()
1346             GUI.edgeStyleMenu = Draw.Menu(edgeStyleMenuStruct, GUI.evtEdgeStyleMenu,
1347                     200, 210, 160, 18, GUI.edgeStyleMenu.val,
1348                     "Choose the edge style")
1349
1350             # Edge size
1351             GUI.edgeWidthSlider = Draw.Slider("Width: ", GUI.evtEdgeWidthSlider,
1352                     200, 185, 140, 18, GUI.edgeWidthSlider.val,
1353                     0.0, 10.0, 0, "Change Edge Width")
1354
1355             # Edge Color
1356             GUI.edgeColorPicker = Draw.ColorPicker(GUI.evtEdgeColorPicker,
1357                     342, 185, 18, 18, GUI.edgeColorPicker.val, "Choose Edge Color")
1358
1359             # Show Hidden Edges
1360             GUI.showHiddenEdgesToggle = Draw.Toggle("Show Hidden Edges",
1361                     GUI.evtShowHiddenEdgesToggle,
1362                     200, 160, 160, 18, GUI.showHiddenEdgesToggle.val,
1363                     "Render hidden edges as dashed lines")
1364
1365         glRasterPos2i(10, 160)
1366         Draw.Text("Antonio Ospite (c) 2006")
1367
1368     def event(evt, val):
1369
1370         if evt == Draw.ESCKEY or evt == Draw.QKEY:
1371             Draw.Exit()
1372         else:
1373             return
1374
1375         Draw.Redraw(1)
1376
1377     def button_event(evt):
1378
1379         if evt == GUI.evtExitButton:
1380             Draw.Exit()
1381
1382         elif evt == GUI.evtOutFormatMenu:
1383             i = GUI.outFormatMenu.val - 1
1384             config.output['FORMAT']= outputWriters.keys()[i]
1385
1386         elif evt == GUI.evtAnimToggle:
1387             config.outpur['ANIMATION'] = bool(GUI.animToggle.val)
1388
1389         elif evt == GUI.evtJoinObjsToggle:
1390             config.output['JOIN_OBJECTS'] = bool(GUI.joinObjsToggle.val)
1391
1392         elif evt == GUI.evtPolygonsToggle:
1393             config.polygons['SHOW'] = bool(GUI.polygonsToggle.val)
1394
1395         elif evt == GUI.evtShadingStyleMenu:
1396             i = GUI.shadingStyleMenu.val - 1
1397             config.polygons['SHADING'] = shadingStyles.keys()[i]
1398
1399         elif evt == GUI.evtShowEdgesToggle:
1400             config.edges['SHOW'] = bool(GUI.showEdgesToggle.val)
1401
1402         elif evt == GUI.evtShowHiddenEdgesToggle:
1403             config.edges['SHOW_HIDDEN'] = bool(GUI.showHiddenEdgesToggle.val)
1404
1405         elif evt == GUI.evtEdgeStyleMenu:
1406             i = GUI.edgeStyleMenu.val - 1
1407             config.edges['STYLE'] = edgeStyles.keys()[i]
1408
1409         elif evt == GUI.evtEdgeWidthSlider:
1410             config.edges['WIDTH'] = float(GUI.edgeWidthSlider.val)
1411
1412         elif evt == GUI.evtEdgeColorPicker:
1413             config.edges['COLOR'] = [int(c*255.0) for c in GUI.edgeColorPicker.val]
1414
1415         elif evt == GUI.evtRenderButton:
1416             label = "Save %s" % config.output['FORMAT']
1417             # Show the File Selector
1418             global outputfile
1419             Blender.Window.FileSelector(vectorize, label, outputfile)
1420
1421         else:
1422             print "Event: %d not handled!" % evt
1423
1424         if evt:
1425             Draw.Redraw(1)
1426             GUI.conf_debug()
1427
1428     def conf_debug():
1429         from pprint import pprint
1430         print "\nConfig"
1431         pprint(config.output)
1432         pprint(config.polygons)
1433         pprint(config.edges)
1434
1435     _init = staticmethod(_init)
1436     draw = staticmethod(draw)
1437     event = staticmethod(event)
1438     button_event = staticmethod(button_event)
1439     conf_debug = staticmethod(conf_debug)
1440
1441 # A wrapper function for the vectorizing process
1442 def vectorize(filename):
1443     """The vectorizing process is as follows:
1444
1445      - Instanciate the writer and the renderer
1446      - Render!
1447      """
1448
1449     if filename == "":
1450         print "\nERROR: invalid file name!"
1451         return
1452
1453     from Blender import Window
1454     editmode = Window.EditMode()
1455     if editmode: Window.EditMode(0)
1456
1457     actualWriter = outputWriters[config.output['FORMAT']]
1458     writer = actualWriter(filename)
1459
1460     renderer = Renderer()
1461     renderer.doRendering(writer, config.output['ANIMATION'])
1462
1463     if editmode: Window.EditMode(1)
1464
1465
1466 # Here the main
1467 if __name__ == "__main__":
1468
1469     outputfile = ""
1470     basename = Blender.sys.basename(Blender.Get('filename'))
1471     if basename != "":
1472         outputfile = Blender.sys.splitext(basename)[0] + "." + str(config.output['FORMAT']).lower()
1473
1474     if Blender.mode == 'background':
1475         vectorize(outputfile)
1476     else:
1477         Draw.Register(GUI.draw, GUI.event, GUI.button_event)