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://projects.blender.org/projects/vrm"]
  11 __version__ = "0.3.beta"
  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 #   - FIX the issue with negative scales in object tranformations!
  46 #   - Use a better depth sorting algorithm
  47 #   - Implement clipping of primitives and do handle object intersections.
  48 #     (for now only clipping away whole objects is supported).
  49 #   - Review how selections are made (this script uses selection states of
  50 #     primitives to represent visibility infos)
  51 #   - Use a data structure other than Mesh to represent the 2D image?
  52 #     Think to a way to merge (adjacent) polygons that have the same color.
  53 #     Or a way to use paths for silhouettes and contours.
  54 #   - Consider SMIL for animation handling instead of ECMA Script? (Firefox do
  55 #     not support SMIL for animations)
  56 #   - Switch to the Mesh structure, should be considerably faster
  57 #     (partially done, but with Mesh we cannot sort faces, yet)
  58 #   - Implement Edge Styles (silhouettes, contours, etc.) (partially done).
  59 #   - Implement Shading Styles? (partially done, to make more flexible).
  60 #   - Add Vector Writers other than SVG.
  61 #   - Check memory use!!
  62 #   - Support Indexed palettes!! (Useful for ILDA FILES, for example,
  63 #     see http://www.linux-laser.org/download/autotrace/ilda-output.patch)
  64 #
  65 # ---------------------------------------------------------------------
  66 #
  67 # Changelog:
  68 #
  69 #   vrm-0.3.py  - ...
  70 #     * First release after code restucturing.
  71 #       Now the script offers a useful set of functionalities
  72 #       and it can render animations, too.
  73 #     * Optimization in Renderer.doEdgeStyle(), build a topology cache
  74 #       so to speed up the lookup of adjacent faces of an edge.
  75 #       Thanks ideasman42.
  76 #     * The SVG output is now SVG 1.0 valid.
  77 #       Checked with: http://jiggles.w3.org/svgvalidator/ValidatorURI.html
  78 #     * Progress indicator during HSR.
  79 #     * Initial SWF output support
  80 #     * Fixed a bug in the animation code, now the projection matrix is
  81 #       recalculated at each frame!
  82 #
  83 # ---------------------------------------------------------------------
  84
  85 import Blender
  86 from Blender import Scene, Object, Mesh, NMesh, Material, Lamp, Camera, Window
  87 from Blender.Mathutils import *
  88 from math import *
  89 import sys, time
  90
  91 # Constants
  92 EPS = 10e-5
  93
  94 # We use a global progress Indicator Object
  95 progress = None
  96
  97
  98 # Some global settings
  99
 100 class config:
 101     polygons = dict()
 102     polygons['SHOW'] = True
 103     polygons['SHADING'] = 'FLAT'
 104     #polygons['HSR'] = 'PAINTER' # 'PAINTER' or 'NEWELL'
 105     polygons['HSR'] = 'PAINTER'
 106     # Hidden to the user for now
 107     polygons['EXPANSION_TRICK'] = True
 108
 109     polygons['TOON_LEVELS'] = 2
 110
 111     edges = dict()
 112     edges['SHOW'] = False
 113     edges['SHOW_HIDDEN'] = False
 114     edges['STYLE'] = 'MESH' # or SILHOUETTE
 115     edges['STYLE'] = 'SILHOUETTE'
 116     edges['WIDTH'] = 2
 117     edges['COLOR'] = [0, 0, 0]
 118
 119     output = dict()
 120     output['FORMAT'] = 'SVG'
 121     output['FORMAT'] = 'SWF'
 122     output['ANIMATION'] = True
 123     output['JOIN_OBJECTS'] = True
 124
 125
 126
 127 # Utility functions
 128 def sign(x):
 129
 130     if x < -EPS:
 131         return -1
 132     elif x > EPS:
 133         return 1
 134     else:
 135         return 0
 136
 137
 138 # ---------------------------------------------------------------------
 139 #
 140 ## Mesh Utility class
 141 #
 142 # ---------------------------------------------------------------------
 143 class MeshUtils:
 144
 145     def buildEdgeFaceUsersCache(me):
 146         '''
 147         Takes a mesh and returns a list aligned with the meshes edges.
 148         Each item is a list of the faces that use the edge
 149         would be the equiv for having ed.face_users as a property
 150
 151         Taken from .blender/scripts/bpymodules/BPyMesh.py,
 152         thanks to ideasman_42.
 153         '''
 154
 155         def sorted_edge_indicies(ed):
 156             i1= ed.v1.index
 157             i2= ed.v2.index
 158             if i1>i2:
 159                 i1,i2= i2,i1
 160             return i1, i2
 161
 162
 163         face_edges_dict= dict([(sorted_edge_indicies(ed), (ed.index, [])) for ed in me.edges])
 164         for f in me.faces:
 165             fvi= [v.index for v in f.v]# face vert idx's
 166             for i in xrange(len(f)):
 167                 i1= fvi[i]
 168                 i2= fvi[i-1]
 169
 170                 if i1>i2:
 171                     i1,i2= i2,i1
 172
 173                 face_edges_dict[i1,i2][1].append(f)
 174
 175         face_edges= [None] * len(me.edges)
 176         for ed_index, ed_faces in face_edges_dict.itervalues():
 177             face_edges[ed_index]= ed_faces
 178
 179         return face_edges
 180
 181     def isMeshEdge(adjacent_faces):
 182         """Mesh edge rule.
 183
 184         A mesh edge is visible if _at_least_one_ of its adjacent faces is selected.
 185         Note: if the edge has no adjacent faces we want to show it as well,
 186         useful for "edge only" portion of objects.
 187         """
 188
 189         if len(adjacent_faces) == 0:
 190             return True
 191
 192         selected_faces = [f for f in adjacent_faces if f.sel]
 193
 194         if len(selected_faces) != 0:
 195             return True
 196         else:
 197             return False
 198
 199     def isSilhouetteEdge(adjacent_faces):
 200         """Silhuette selection rule.
 201
 202         An edge is a silhuette edge if it is shared by two faces with
 203         different selection status or if it is a boundary edge of a selected
 204         face.
 205         """
 206
 207         if ((len(adjacent_faces) == 1 and adjacent_faces[0].sel == 1) or
 208             (len(adjacent_faces) == 2 and
 209                 adjacent_faces[0].sel != adjacent_faces[1].sel)
 210             ):
 211             return True
 212         else:
 213             return False
 214
 215     buildEdgeFaceUsersCache = staticmethod(buildEdgeFaceUsersCache)
 216     isMeshEdge = staticmethod(isMeshEdge)
 217     isSilhouetteEdge = staticmethod(isSilhouetteEdge)
 218
 219
 220 # ---------------------------------------------------------------------
 221 #
 222 ## Shading Utility class
 223 #
 224 # ---------------------------------------------------------------------
 225 class ShadingUtils:
 226
 227     shademap = None
 228
 229     def toonShadingMapSetup():
 230         levels = config.polygons['TOON_LEVELS']
 231
 232         texels = 2*levels - 1
 233         tmp_shademap = [0.0] + [(i)/float(texels-1) for i in xrange(1, texels-1) ] + [1.0]
 234
 235         return tmp_shademap
 236
 237     def toonShading(u):
 238
 239         shademap = ShadingUtils.shademap
 240
 241         if not shademap:
 242             shademap = ShadingUtils.toonShadingMapSetup()
 243
 244         v = 1.0
 245         for i in xrange(0, len(shademap)-1):
 246             pivot = (shademap[i]+shademap[i+1])/2.0
 247             j = int(u>pivot)
 248
 249             v = shademap[i+j]
 250
 251             if v < shademap[i+1]:
 252                 return v
 253
 254         return v
 255
 256     toonShadingMapSetup = staticmethod(toonShadingMapSetup)
 257     toonShading = staticmethod(toonShading)
 258
 259
 260 # ---------------------------------------------------------------------
 261 #
 262 ## Projections classes
 263 #
 264 # ---------------------------------------------------------------------
 265
 266 class Projector:
 267     """Calculate the projection of an object given the camera.
 268
 269     A projector is useful to so some per-object transformation to obtain the
 270     projection of an object given the camera.
 271
 272     The main method is #doProjection# see the method description for the
 273     parameter list.
 274     """
 275
 276     def __init__(self, cameraObj, canvasRatio):
 277         """Calculate the projection matrix.
 278
 279         The projection matrix depends, in this case, on the camera settings.
 280         TAKE CARE: This projector expects vertices in World Coordinates!
 281         """
 282
 283         camera = cameraObj.getData()
 284
 285         aspect = float(canvasRatio[0])/float(canvasRatio[1])
 286         near = camera.clipStart
 287         far = camera.clipEnd
 288
 289         scale = float(camera.scale)
 290
 291         fovy = atan(0.5/aspect/(camera.lens/32))
 292         fovy = fovy * 360.0/pi
 293
 294         # What projection do we want?
 295         if camera.type == 0:
 296             mP = self._calcPerspectiveMatrix(fovy, aspect, near, far)
 297         elif camera.type == 1:
 298             mP = self._calcOrthoMatrix(fovy, aspect, near, far, scale)
 299
 300         # View transformation
 301         cam = Matrix(cameraObj.getInverseMatrix())
 302         cam.transpose()
 303
 304         mP = mP * cam
 305
 306         self.projectionMatrix = mP
 307
 308     ##
 309     # Public methods
 310     #
 311
 312     def doProjection(self, v):
 313         """Project the point on the view plane.
 314
 315         Given a vertex calculate the projection using the current projection
 316         matrix.
 317         """
 318
 319         # Note that we have to work on the vertex using homogeneous coordinates
 320         # From blender 2.42+ we don't need to resize the vector to be 4d
 321         # when applying a 4x4 matrix, but we do that anyway since we need the
 322         # 4th coordinate later
 323         p = self.projectionMatrix * Vector(v).resize4D()
 324
 325         # Perspective division
 326         if p[3] != 0:
 327             p[0] = p[0]/p[3]
 328             p[1] = p[1]/p[3]
 329             p[2] = p[2]/p[3]
 330
 331         # restore the size
 332         p[3] = 1.0
 333         p.resize3D()
 334
 335         return p
 336
 337
 338     ##
 339     # Private methods
 340     #
 341
 342     def _calcPerspectiveMatrix(self, fovy, aspect, near, far):
 343         """Return a perspective projection matrix.
 344         """
 345
 346         top = near * tan(fovy * pi / 360.0)
 347         bottom = -top
 348         left = bottom*aspect
 349         right= top*aspect
 350         x = (2.0 * near) / (right-left)
 351         y = (2.0 * near) / (top-bottom)
 352         a = (right+left) / (right-left)
 353         b = (top+bottom) / (top - bottom)
 354         c = - ((far+near) / (far-near))
 355         d = - ((2*far*near)/(far-near))
 356
 357         m = Matrix(
 358                 [x,   0.0,    a,    0.0],
 359                 [0.0,   y,    b,    0.0],
 360                 [0.0, 0.0,    c,      d],
 361                 [0.0, 0.0, -1.0,    0.0])
 362
 363         return m
 364
 365     def _calcOrthoMatrix(self, fovy, aspect , near, far, scale):
 366         """Return an orthogonal projection matrix.
 367         """
 368
 369         # The 11 in the formula was found emiprically
 370         top = near * tan(fovy * pi / 360.0) * (scale * 11)
 371         bottom = -top
 372         left = bottom * aspect
 373         right= top * aspect
 374         rl = right-left
 375         tb = top-bottom
 376         fn = near-far
 377         tx = -((right+left)/rl)
 378         ty = -((top+bottom)/tb)
 379         tz = ((far+near)/fn)
 380
 381         m = Matrix(
 382                 [2.0/rl, 0.0,    0.0,     tx],
 383                 [0.0,    2.0/tb, 0.0,     ty],
 384                 [0.0,    0.0,    2.0/fn,  tz],
 385                 [0.0,    0.0,    0.0,    1.0])
 386
 387         return m
 388
 389
 390 # ---------------------------------------------------------------------
 391 #
 392 ## Progress Indicator
 393 #
 394 # ---------------------------------------------------------------------
 395
 396 class Progress:
 397     """A model for a progress indicator.
 398
 399     Do the progress calculation calculation and
 400     the view independent stuff of a progress indicator.
 401     """
 402     def __init__(self, steps=0):
 403         self.name = ""
 404         self.steps = steps
 405         self.completed = 0
 406         self.progress = 0
 407
 408     def setSteps(self, steps):
 409         """Set the number of steps of the activity wich we want to track.
 410         """
 411         self.steps = steps
 412
 413     def getSteps(self):
 414         return self.steps
 415
 416     def setName(self, name):
 417         """Set the name of the activity wich we want to track.
 418         """
 419         self.name = name
 420
 421     def getName(self):
 422         return self.name
 423
 424     def getProgress(self):
 425         return self.progress
 426
 427     def reset(self):
 428         self.completed = 0
 429         self.progress = 0
 430
 431     def update(self):
 432         """Update the model, call this method when one step is completed.
 433         """
 434         if self.progress == 100:
 435             return False
 436
 437         self.completed += 1
 438         self.progress = ( float(self.completed) / float(self.steps) ) * 100
 439         self.progress = int(self.progress)
 440
 441         return True
 442
 443
 444 class ProgressIndicator:
 445     """An abstraction of a View for the Progress Model
 446     """
 447     def __init__(self):
 448
 449         # Use a refresh rate so we do not show the progress at
 450         # every update, but every 'self.refresh_rate' times.
 451         self.refresh_rate = 10
 452         self.shows_counter = 0
 453
 454         self.quiet = False
 455
 456         self.progressModel = None
 457
 458     def setQuiet(self, value):
 459         self.quiet = value
 460
 461     def setActivity(self, name, steps):
 462         """Initialize the Model.
 463
 464         In a future version (with subactivities-progress support) this method
 465         could only set the current activity.
 466         """
 467         self.progressModel = Progress()
 468         self.progressModel.setName(name)
 469         self.progressModel.setSteps(steps)
 470
 471     def getActivity(self):
 472         return self.progressModel
 473
 474     def update(self):
 475         """Update the model and show the actual progress.
 476         """
 477         assert(self.progressModel)
 478
 479         if self.progressModel.update():
 480             if self.quiet:
 481                 return
 482
 483             self.show(self.progressModel.getProgress(),
 484                     self.progressModel.getName())
 485
 486         # We return always True here so we can call the update() method also
 487         # from lambda funcs (putting the call in logical AND with other ops)
 488         return True
 489
 490     def show(self, progress, name=""):
 491         self.shows_counter = (self.shows_counter + 1) % self.refresh_rate
 492         if self.shows_counter != 0:
 493             return
 494
 495         if progress == 100:
 496             self.shows_counter = -1
 497
 498
 499 class ConsoleProgressIndicator(ProgressIndicator):
 500     """Show a progress bar on stderr, a la wget.
 501     """
 502     def __init__(self):
 503         ProgressIndicator.__init__(self)
 504
 505         self.swirl_chars = ["-", "\\", "|", "/"]
 506         self.swirl_count = -1
 507
 508     def show(self, progress, name):
 509         ProgressIndicator.show(self, progress, name)
 510
 511         bar_length = 70
 512         bar_progress = int( (progress/100.0) * bar_length )
 513         bar = ("=" * bar_progress).ljust(bar_length)
 514
 515         self.swirl_count = (self.swirl_count+1)%len(self.swirl_chars)
 516         swirl_char = self.swirl_chars[self.swirl_count]
 517
 518         progress_bar = "%s |%s| %c %3d%%" % (name, bar, swirl_char, progress)
 519
 520         sys.stderr.write(progress_bar+"\r")
 521         if progress == 100:
 522             sys.stderr.write("\n")
 523
 524
 525 class GraphicalProgressIndicator(ProgressIndicator):
 526     """Interface to the Blender.Window.DrawProgressBar() method.
 527     """
 528     def __init__(self):
 529         ProgressIndicator.__init__(self)
 530
 531         #self.swirl_chars = ["-", "\\", "|", "/"]
 532         # We have to use letters with the same width, for now!
 533         # Blender progress bar considers the font widths when
 534         # calculating the progress bar width.
 535         self.swirl_chars = ["\\", "/"]
 536         self.swirl_count = -1
 537
 538     def show(self, progress, name):
 539         ProgressIndicator.show(self, progress)
 540
 541         self.swirl_count = (self.swirl_count+1)%len(self.swirl_chars)
 542         swirl_char = self.swirl_chars[self.swirl_count]
 543
 544         progress_text = "%s - %c %3d%%" % (name, swirl_char, progress)
 545
 546         # Finally draw  the Progress Bar
 547         Window.WaitCursor(1) # Maybe we can move that call in the constructor?
 548         Window.DrawProgressBar(progress/100.0, progress_text)
 549
 550         if progress == 100:
 551             Window.DrawProgressBar(1, progress_text)
 552             Window.WaitCursor(0)
 553
 554
 555
 556 # ---------------------------------------------------------------------
 557 #
 558 ## 2D Object representation class
 559 #
 560 # ---------------------------------------------------------------------
 561
 562 # TODO: a class to represent the needed properties of a 2D vector image
 563 # For now just using a [N]Mesh structure.
 564
 565
 566 # ---------------------------------------------------------------------
 567 #
 568 ## Vector Drawing Classes
 569 #
 570 # ---------------------------------------------------------------------
 571
 572 ## A generic Writer
 573
 574 class VectorWriter:
 575     """
 576     A class for printing output in a vectorial format.
 577
 578     Given a 2D representation of the 3D scene the class is responsible to
 579     write it is a vector format.
 580
 581     Every subclasses of VectorWriter must have at last the following public
 582     methods:
 583         - open(self)
 584         - close(self)
 585         - printCanvas(self, scene,
 586             doPrintPolygons=True, doPrintEdges=False, showHiddenEdges=False):
 587     """
 588
 589     def __init__(self, fileName):
 590         """Set the output file name and other properties"""
 591
 592         self.outputFileName = fileName
 593         self.file = None
 594
 595         context = Scene.GetCurrent().getRenderingContext()
 596         self.canvasSize = ( context.imageSizeX(), context.imageSizeY() )
 597
 598         self.startFrame = 1
 599         self.endFrame = 1
 600         self.animation = False
 601
 602
 603     ##
 604     # Public Methods
 605     #
 606
 607     def open(self, startFrame=1, endFrame=1):
 608         if startFrame != endFrame:
 609             self.startFrame = startFrame
 610             self.endFrame = endFrame
 611             self.animation = True
 612
 613         self.file = open(self.outputFileName, "w")
 614         print "Outputting to: ", self.outputFileName
 615
 616         return
 617
 618     def close(self):
 619         if self.file:
 620             self.file.close()
 621         return
 622
 623     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
 624             showHiddenEdges=False):
 625         """This is the interface for the needed printing routine.
 626         """
 627         return
 628
 629
 630 ## SVG Writer
 631
 632 class SVGVectorWriter(VectorWriter):
 633     """A concrete class for writing SVG output.
 634     """
 635
 636     def __init__(self, fileName):
 637         """Simply call the parent Contructor.
 638         """
 639         VectorWriter.__init__(self, fileName)
 640
 641
 642     ##
 643     # Public Methods
 644     #
 645
 646     def open(self, startFrame=1, endFrame=1):
 647         """Do some initialization operations.
 648         """
 649         VectorWriter.open(self, startFrame, endFrame)
 650         self._printHeader()
 651
 652     def close(self):
 653         """Do some finalization operation.
 654         """
 655         self._printFooter()
 656
 657         # remember to call the close method of the parent
 658         VectorWriter.close(self)
 659
 660
 661     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
 662             showHiddenEdges=False):
 663         """Convert the scene representation to SVG.
 664         """
 665
 666         Objects = scene.getChildren()
 667
 668         context = scene.getRenderingContext()
 669         framenumber = context.currentFrame()
 670
 671         if self.animation:
 672             framestyle = "display:none"
 673         else:
 674             framestyle = "display:block"
 675
 676         # Assign an id to this group so we can set properties on it using DOM
 677         self.file.write("<g id=\"frame%d\" style=\"%s\">\n" %
 678                 (framenumber, framestyle) )
 679
 680
 681         for obj in Objects:
 682
 683             if(obj.getType() != 'Mesh'):
 684                 continue
 685
 686             self.file.write("<g id=\"%s\">\n" % obj.getName())
 687
 688             mesh = obj.getData(mesh=1)
 689
 690             if doPrintPolygons:
 691                 self._printPolygons(mesh)
 692
 693             if doPrintEdges:
 694                 self._printEdges(mesh, showHiddenEdges)
 695
 696             self.file.write("</g>\n")
 697
 698         self.file.write("</g>\n")
 699
 700
 701     ##
 702     # Private Methods
 703     #
 704
 705     def _calcCanvasCoord(self, v):
 706         """Convert vertex in scene coordinates to canvas coordinates.
 707         """
 708
 709         pt = Vector([0, 0, 0])
 710
 711         mW = float(self.canvasSize[0])/2.0
 712         mH = float(self.canvasSize[1])/2.0
 713
 714         # rescale to canvas size
 715         pt[0] = v.co[0]*mW + mW
 716         pt[1] = v.co[1]*mH + mH
 717         pt[2] = v.co[2]
 718
 719         # For now we want (0,0) in the top-left corner of the canvas.
 720         # Mirror and translate along y
 721         pt[1] *= -1
 722         pt[1] += self.canvasSize[1]
 723
 724         return pt
 725
 726     def _printHeader(self):
 727         """Print SVG header."""
 728
 729         self.file.write("<?xml version=\"1.0\"?>\n")
 730         self.file.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.0//EN\"\n")
 731         self.file.write("\t\"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd\">\n")
 732         self.file.write("<svg version=\"1.0\"\n")
 733         self.file.write("\txmlns=\"http://www.w3.org/2000/svg\"\n")
 734         self.file.write("\twidth=\"%d\" height=\"%d\">\n\n" %
 735                 self.canvasSize)
 736
 737         if self.animation:
 738
 739             self.file.write("""\n<script type="text/javascript"><![CDATA[
 740             globalStartFrame=%d;
 741             globalEndFrame=%d;
 742
 743             /* FIXME: Use 1000 as interval as lower values gives problems */
 744             timerID = setInterval("NextFrame()", 1000);
 745             globalFrameCounter=%d;
 746
 747             function NextFrame()
 748             {
 749               currentElement  = document.getElementById('frame'+globalFrameCounter)
 750               previousElement = document.getElementById('frame'+(globalFrameCounter-1))
 751
 752               if (!currentElement)
 753               {
 754                 return;
 755               }
 756
 757               if (globalFrameCounter > globalEndFrame)
 758               {
 759                 clearInterval(timerID)
 760               }
 761               else
 762               {
 763                 if(previousElement)
 764                 {
 765                     previousElement.style.display="none";
 766                 }
 767                 currentElement.style.display="block";
 768                 globalFrameCounter++;
 769               }
 770             }
 771             \n]]></script>\n
 772             \n""" % (self.startFrame, self.endFrame, self.startFrame) )
 773
 774     def _printFooter(self):
 775         """Print the SVG footer."""
 776
 777         self.file.write("\n</svg>\n")
 778
 779     def _printPolygons(self, mesh):
 780         """Print the selected (visible) polygons.
 781         """
 782
 783         if len(mesh.faces) == 0:
 784             return
 785
 786         self.file.write("<g>\n")
 787
 788         for face in mesh.faces:
 789             if not face.sel:
 790                continue
 791
 792             self.file.write("<path d=\"")
 793
 794             p = self._calcCanvasCoord(face.verts[0])
 795             self.file.write("M %g,%g L " % (p[0], p[1]))
 796
 797             for v in face.verts[1:]:
 798                 p = self._calcCanvasCoord(v)
 799                 self.file.write("%g,%g " % (p[0], p[1]))
 800
 801             # get rid of the last blank space, just cosmetics here.
 802             self.file.seek(-1, 1)
 803             self.file.write(" z\"\n")
 804
 805             # take as face color the first vertex color
 806             if face.col:
 807                 fcol = face.col[0]
 808                 color = [fcol.r, fcol.g, fcol.b, fcol.a]
 809             else:
 810                 color = [255, 255, 255, 255]
 811
 812             # Convert the color to the #RRGGBB form
 813             str_col = "#%02X%02X%02X" % (color[0], color[1], color[2])
 814
 815             # Handle transparent polygons
 816             opacity_string = ""
 817             if color[3] != 255:
 818                 opacity = float(color[3])/255.0
 819                 opacity_string = " fill-opacity: %g; stroke-opacity: %g; opacity: 1;" % (opacity, opacity)
 820                 #opacity_string = "opacity: %g;" % (opacity)
 821
 822             self.file.write("\tstyle=\"fill:" + str_col + ";")
 823             self.file.write(opacity_string)
 824
 825             # use the stroke property to alleviate the "adjacent edges" problem,
 826             # we simulate polygon expansion using borders,
 827             # see http://www.antigrain.com/svg/index.html for more info
 828             stroke_width = 1.0
 829
 830             # EXPANSION TRICK is not that useful where there is transparency
 831             if config.polygons['EXPANSION_TRICK'] and color[3] == 255:
 832                 # str_col = "#000000" # For debug
 833                 self.file.write(" stroke:%s;\n" % str_col)
 834                 self.file.write(" stroke-width:" + str(stroke_width) + ";\n")
 835                 self.file.write(" stroke-linecap:round;stroke-linejoin:round")
 836
 837             self.file.write("\"/>\n")
 838
 839         self.file.write("</g>\n")
 840
 841     def _printEdges(self, mesh, showHiddenEdges=False):
 842         """Print the wireframe using mesh edges.
 843         """
 844
 845         stroke_width = config.edges['WIDTH']
 846         stroke_col = config.edges['COLOR']
 847
 848         self.file.write("<g>\n")
 849
 850         for e in mesh.edges:
 851
 852             hidden_stroke_style = ""
 853
 854             if e.sel == 0:
 855                 if showHiddenEdges == False:
 856                     continue
 857                 else:
 858                     hidden_stroke_style = ";\n stroke-dasharray:3, 3"
 859
 860             p1 = self._calcCanvasCoord(e.v1)
 861             p2 = self._calcCanvasCoord(e.v2)
 862
 863             self.file.write("<line x1=\"%g\" y1=\"%g\" x2=\"%g\" y2=\"%g\"\n"
 864                     % ( p1[0], p1[1], p2[0], p2[1] ) )
 865             self.file.write(" style=\"stroke:rgb("+str(stroke_col[0])+","+str(stroke_col[1])+","+str(stroke_col[2])+");")
 866             self.file.write(" stroke-width:"+str(stroke_width)+";\n")
 867             self.file.write(" stroke-linecap:round;stroke-linejoin:round")
 868             self.file.write(hidden_stroke_style)
 869             self.file.write("\"/>\n")
 870
 871         self.file.write("</g>\n")
 872
 873
 874 ## SWF Writer
 875
 876 from ming import *
 877
 878 class SWFVectorWriter(VectorWriter):
 879     """A concrete class for writing SWF output.
 880     """
 881
 882     def __init__(self, fileName):
 883         """Simply call the parent Contructor.
 884         """
 885         VectorWriter.__init__(self, fileName)
 886
 887         self.movie = None
 888         self.sprite = None
 889
 890
 891     ##
 892     # Public Methods
 893     #
 894
 895     def open(self, startFrame=1, endFrame=1):
 896         """Do some initialization operations.
 897         """
 898         VectorWriter.open(self, startFrame, endFrame)
 899         self.movie = SWFMovie()
 900         self.movie.setDimension(self.canvasSize[0], self.canvasSize[1])
 901         # set fps
 902         self.movie.setRate(25)
 903         numframes = endFrame - startFrame + 1
 904         self.movie.setFrames(numframes)
 905
 906     def close(self):
 907         """Do some finalization operation.
 908         """
 909         self.movie.save(self.outputFileName)
 910
 911         # remember to call the close method of the parent
 912         VectorWriter.close(self)
 913
 914     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
 915             showHiddenEdges=False):
 916         """Convert the scene representation to SVG.
 917         """
 918         context = scene.getRenderingContext()
 919         framenumber = context.currentFrame()
 920
 921         Objects = scene.getChildren()
 922
 923         if self.sprite:
 924             self.movie.remove(self.sprite)
 925
 926         sprite = SWFSprite()
 927
 928         for obj in Objects:
 929
 930             if(obj.getType() != 'Mesh'):
 931                 continue
 932
 933             mesh = obj.getData(mesh=1)
 934
 935             if doPrintPolygons:
 936                 self._printPolygons(mesh, sprite)
 937
 938             if doPrintEdges:
 939                 self._printEdges(mesh, sprite, showHiddenEdges)
 940
 941         sprite.nextFrame()
 942         i = self.movie.add(sprite)
 943         # Remove the instance the next time
 944         self.sprite = i
 945         if self.animation:
 946             self.movie.nextFrame()
 947
 948
 949     ##
 950     # Private Methods
 951     #
 952
 953     def _calcCanvasCoord(self, v):
 954         """Convert vertex in scene coordinates to canvas coordinates.
 955         """
 956
 957         pt = Vector([0, 0, 0])
 958
 959         mW = float(self.canvasSize[0])/2.0
 960         mH = float(self.canvasSize[1])/2.0
 961
 962         # rescale to canvas size
 963         pt[0] = v.co[0]*mW + mW
 964         pt[1] = v.co[1]*mH + mH
 965         pt[2] = v.co[2]
 966
 967         # For now we want (0,0) in the top-left corner of the canvas.
 968         # Mirror and translate along y
 969         pt[1] *= -1
 970         pt[1] += self.canvasSize[1]
 971
 972         return pt
 973
 974     def _printPolygons(self, mesh, sprite):
 975         """Print the selected (visible) polygons.
 976         """
 977
 978         if len(mesh.faces) == 0:
 979             return
 980
 981         for face in mesh.faces:
 982             if not face.sel:
 983                continue
 984
 985             if face.col:
 986                 fcol = face.col[0]
 987                 color = [fcol.r, fcol.g, fcol.b, fcol.a]
 988             else:
 989                 color = [255, 255, 255, 255]
 990
 991             s = SWFShape()
 992             f = s.addFill(color[0], color[1], color[2], color[3])
 993             s.setRightFill(f)
 994
 995             # The starting point of the shape
 996             p0 = self._calcCanvasCoord(face.verts[0])
 997             s.movePenTo(p0[0], p0[1])
 998
 999
1000             for v in face.verts[1:]:
1001                 p = self._calcCanvasCoord(v)
1002                 s.drawLineTo(p[0], p[1])
1003
1004             # Closing the shape
1005             s.drawLineTo(p0[0], p0[1])
1006             s.end()
1007             sprite.add(s)
1008
1009
1010             """
1011             # use the stroke property to alleviate the "adjacent edges" problem,
1012             # we simulate polygon expansion using borders,
1013             # see http://www.antigrain.com/svg/index.html for more info
1014             stroke_width = 1.0
1015
1016             # EXPANSION TRICK is not that useful where there is transparency
1017             if config.polygons['EXPANSION_TRICK'] and color[3] == 255:
1018                 # str_col = "#000000" # For debug
1019                 self.file.write(" stroke:%s;\n" % str_col)
1020                 self.file.write(" stroke-width:" + str(stroke_width) + ";\n")
1021                 self.file.write(" stroke-linecap:round;stroke-linejoin:round")
1022
1023             """
1024
1025     def _printEdges(self, mesh, sprite, showHiddenEdges=False):
1026         """Print the wireframe using mesh edges.
1027         """
1028
1029         stroke_width = config.edges['WIDTH']
1030         stroke_col = config.edges['COLOR']
1031
1032         s = SWFShape()
1033
1034         for e in mesh.edges:
1035
1036             #Next, we set the line width and color for our shape.
1037             s.setLine(stroke_width, stroke_col[0], stroke_col[1], stroke_col[2],
1038             255)
1039
1040             if e.sel == 0:
1041                 if showHiddenEdges == False:
1042                     continue
1043                 else:
1044                     # SWF does not support dashed lines natively, so -for now-
1045                     # draw hidden lines thinner and half-trasparent
1046                     s.setLine(stroke_width/2, stroke_col[0], stroke_col[1],
1047                             stroke_col[2], 128)
1048
1049             p1 = self._calcCanvasCoord(e.v1)
1050             p2 = self._calcCanvasCoord(e.v2)
1051
1052             # FIXME: this is just a qorkaround, remove that after the
1053             # implementation of propoer Viewport clipping
1054             if abs(p1[0]) < 3000 and abs(p2[0]) < 3000 and abs(p1[1]) < 3000 and abs(p1[2]) < 3000:
1055                 s.movePenTo(p1[0], p1[1])
1056                 s.drawLineTo(p2[0], p2[1])
1057
1058
1059         s.end()
1060         sprite.add(s)
1061
1062
1063
1064 # ---------------------------------------------------------------------
1065 #
1066 ## Rendering Classes
1067 #
1068 # ---------------------------------------------------------------------
1069
1070 # A dictionary to collect different shading style methods
1071 shadingStyles = dict()
1072 shadingStyles['FLAT'] = None
1073 shadingStyles['TOON'] = None
1074
1075 # A dictionary to collect different edge style methods
1076 edgeStyles = dict()
1077 edgeStyles['MESH'] = MeshUtils.isMeshEdge
1078 edgeStyles['SILHOUETTE'] = MeshUtils.isSilhouetteEdge
1079
1080 # A dictionary to collect the supported output formats
1081 outputWriters = dict()
1082 outputWriters['SVG'] = SVGVectorWriter
1083 outputWriters['SWF'] = SWFVectorWriter
1084
1085
1086 class Renderer:
1087     """Render a scene viewed from the active camera.
1088
1089     This class is responsible of the rendering process, transformation and
1090     projection of the objects in the scene are invoked by the renderer.
1091
1092     The rendering is done using the active camera for the current scene.
1093     """
1094
1095     def __init__(self):
1096         """Make the rendering process only for the current scene by default.
1097
1098         We will work on a copy of the scene, to be sure that the current scene do
1099         not get modified in any way.
1100         """
1101
1102         # Render the current Scene, this should be a READ-ONLY property
1103         self._SCENE = Scene.GetCurrent()
1104
1105         # Use the aspect ratio of the scene rendering context
1106         context = self._SCENE.getRenderingContext()
1107
1108         aspect_ratio = float(context.imageSizeX())/float(context.imageSizeY())
1109         self.canvasRatio = (float(context.aspectRatioX())*aspect_ratio,
1110                             float(context.aspectRatioY())
1111                             )
1112
1113         # Render from the currently active camera
1114         self.cameraObj = self._SCENE.getCurrentCamera()
1115
1116         # Get the list of lighting sources
1117         obj_lst = self._SCENE.getChildren()
1118         self.lights = [ o for o in obj_lst if o.getType() == 'Lamp']
1119
1120         # When there are no lights we use a default lighting source
1121         # that have the same position of the camera
1122         if len(self.lights) == 0:
1123             l = Lamp.New('Lamp')
1124             lobj = Object.New('Lamp')
1125             lobj.loc = self.cameraObj.loc
1126             lobj.link(l)
1127             self.lights.append(lobj)
1128
1129
1130     ##
1131     # Public Methods
1132     #
1133
1134     def doRendering(self, outputWriter, animation=False):
1135         """Render picture or animation and write it out.
1136
1137         The parameters are:
1138             - a Vector writer object that will be used to output the result.
1139             - a flag to tell if we want to render an animation or only the
1140               current frame.
1141         """
1142
1143         context = self._SCENE.getRenderingContext()
1144         origCurrentFrame = context.currentFrame()
1145
1146         # Handle the animation case
1147         if not animation:
1148             startFrame = origCurrentFrame
1149             endFrame = startFrame
1150             outputWriter.open()
1151         else:
1152             startFrame = context.startFrame()
1153             endFrame = context.endFrame()
1154             outputWriter.open(startFrame, endFrame)
1155
1156         # Do the rendering process frame by frame
1157         print "Start Rendering of %d frames" % (endFrame-startFrame)
1158         for f in xrange(startFrame, endFrame+1):
1159             print "\n\nFrame: %d" % f
1160             context.currentFrame(f)
1161
1162             # Use some temporary workspace, a full copy of the scene
1163             inputScene = self._SCENE.copy(2)
1164             # And Set our camera accordingly
1165             self.cameraObj = inputScene.getCurrentCamera()
1166
1167             # Get a projector for this camera.
1168             # NOTE: the projector wants object in world coordinates,
1169             # so we should remember to apply modelview transformations
1170             # _before_ we do projection transformations.
1171             self.proj = Projector(self.cameraObj, self.canvasRatio)
1172
1173             try:
1174                 renderedScene = self.doRenderScene(inputScene)
1175             except :
1176                 print "There was an error! Aborting."
1177                 import traceback
1178                 print traceback.print_exc()
1179
1180                 self._SCENE.makeCurrent()
1181                 Scene.unlink(inputScene)
1182                 del inputScene
1183                 return
1184
1185             outputWriter.printCanvas(renderedScene,
1186                     doPrintPolygons = config.polygons['SHOW'],
1187                     doPrintEdges    = config.edges['SHOW'],
1188                     showHiddenEdges = config.edges['SHOW_HIDDEN'])
1189
1190             # delete the rendered scene
1191             self._SCENE.makeCurrent()
1192             Scene.unlink(renderedScene)
1193             del renderedScene
1194
1195         outputWriter.close()
1196         print "Done!"
1197         context.currentFrame(origCurrentFrame)
1198
1199
1200     def doRenderScene(self, workScene):
1201         """Control the rendering process.
1202
1203         Here we control the entire rendering process invoking the operation
1204         needed to transform and project the 3D scene in two dimensions.
1205         """
1206
1207         # global processing of the scene
1208
1209         self._doSceneClipping(workScene)
1210
1211         self._doConvertGeometricObjsToMesh(workScene)
1212
1213         if config.output['JOIN_OBJECTS']:
1214             self._joinMeshObjectsInScene(workScene)
1215
1216         self._doSceneDepthSorting(workScene)
1217
1218         # Per object activities
1219
1220         Objects = workScene.getChildren()
1221         print "Total Objects: %d" % len(Objects)
1222         for i,obj in enumerate(Objects):
1223             print "\n\n-------"
1224             print "Rendering Object: %d" % i
1225
1226             if obj.getType() != 'Mesh':
1227                 print "Only Mesh supported! - Skipping type:", obj.getType()
1228                 continue
1229
1230             print "Rendering: ", obj.getName()
1231
1232             mesh = obj.getData(mesh=1)
1233
1234             self._doModelingTransformation(mesh, obj.matrix)
1235
1236             self._doBackFaceCulling(mesh)
1237
1238
1239             # When doing HSR with NEWELL we may want to flip all normals
1240             # toward the viewer
1241             if config.polygons['HSR'] == "NEWELL":
1242                 for f in mesh.faces:
1243                     f.sel = 1-f.sel
1244                 mesh.flipNormals()
1245                 for f in mesh.faces:
1246                     f.sel = 1
1247
1248             self._doLighting(mesh)
1249
1250             # Do "projection" now so we perform further processing
1251             # in Normalized View Coordinates
1252             self._doProjection(mesh, self.proj)
1253
1254             self._doViewFrustumClipping(mesh)
1255
1256             self._doHiddenSurfaceRemoval(mesh)
1257
1258             self._doEdgesStyle(mesh, edgeStyles[config.edges['STYLE']])
1259
1260             # Update the object data, important! :)
1261             mesh.update()
1262
1263         return workScene
1264
1265
1266     ##
1267     # Private Methods
1268     #
1269
1270     # Utility methods
1271
1272     def _getObjPosition(self, obj):
1273         """Return the obj position in World coordinates.
1274         """
1275         return obj.matrix.translationPart()
1276
1277     def _cameraViewVector(self):
1278         """Get the View Direction form the camera matrix.
1279         """
1280         return Vector(self.cameraObj.matrix[2]).resize3D()
1281
1282
1283     # Faces methods
1284
1285     def _isFaceVisible(self, face):
1286         """Determine if a face of an object is visible from the current camera.
1287
1288         The view vector is calculated from the camera location and one of the
1289         vertices of the face (expressed in World coordinates, after applying
1290         modelview transformations).
1291
1292         After those transformations we determine if a face is visible by
1293         computing the angle between the face normal and the view vector, this
1294         angle has to be between -90 and 90 degrees for the face to be visible.
1295         This corresponds somehow to the dot product between the two, if it
1296         results > 0 then the face is visible.
1297
1298         There is no need to normalize those vectors since we are only interested in
1299         the sign of the cross product and not in the product value.
1300
1301         NOTE: here we assume the face vertices are in WorldCoordinates, so
1302         please transform the object _before_ doing the test.
1303         """
1304
1305         normal = Vector(face.no)
1306         camPos = self._getObjPosition(self.cameraObj)
1307         view_vect = None
1308
1309         # View Vector in orthographics projections is the view Direction of
1310         # the camera
1311         if self.cameraObj.data.getType() == 1:
1312             view_vect = self._cameraViewVector()
1313
1314         # View vector in perspective projections can be considered as
1315         # the difference between the camera position and one point of
1316         # the face, we choose the farthest point from the camera.
1317         if self.cameraObj.data.getType() == 0:
1318             vv = max( [ ((camPos - Vector(v.co)).length, (camPos - Vector(v.co))) for v in face] )
1319             view_vect = vv[1]
1320
1321
1322         # if d > 0 the face is visible from the camera
1323         d = view_vect * normal
1324
1325         if d > 0:
1326             return True
1327         else:
1328             return False
1329
1330
1331     # Scene methods
1332
1333     def _doSceneClipping(self, scene):
1334         """Clip whole objects against the View Frustum.
1335
1336         For now clip away only objects according to their center position.
1337         """
1338
1339         cpos = self._getObjPosition(self.cameraObj)
1340         view_vect = self._cameraViewVector()
1341
1342         near = self.cameraObj.data.clipStart
1343         far  = self.cameraObj.data.clipEnd
1344
1345         aspect = float(self.canvasRatio[0])/float(self.canvasRatio[1])
1346         fovy = atan(0.5/aspect/(self.cameraObj.data.lens/32))
1347         fovy = fovy * 360.0/pi
1348
1349         Objects = scene.getChildren()
1350         for o in Objects:
1351             if o.getType() != 'Mesh': continue;
1352
1353             obj_vect = Vector(cpos) - self._getObjPosition(o)
1354
1355             d = obj_vect*view_vect
1356             theta = AngleBetweenVecs(obj_vect, view_vect)
1357
1358             # if the object is outside the view frustum, clip it away
1359             if (d < near) or (d > far) or (theta > fovy):
1360                 scene.unlink(o)
1361
1362     def _doConvertGeometricObjsToMesh(self, scene):
1363         """Convert all "geometric" objects to mesh ones.
1364         """
1365         geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text']
1366         #geometricObjTypes = ['Mesh', 'Surf', 'Curve']
1367
1368         Objects = scene.getChildren()
1369         objList = [ o for o in Objects if o.getType() in geometricObjTypes ]
1370         for obj in objList:
1371             old_obj = obj
1372             obj = self._convertToRawMeshObj(obj)
1373             scene.link(obj)
1374             scene.unlink(old_obj)
1375
1376
1377             # XXX Workaround for Text and Curve which have some normals
1378             # inverted when they are converted to Mesh, REMOVE that when
1379             # blender will fix that!!
1380             if old_obj.getType() in ['Curve', 'Text']:
1381                 me = obj.getData(mesh=1)
1382                 for f in me.faces: f.sel = 1;
1383                 for v in me.verts: v.sel = 1;
1384                 me.remDoubles(0)
1385                 me.triangleToQuad()
1386                 me.recalcNormals()
1387                 me.update()
1388
1389
1390     def _doSceneDepthSorting(self, scene):
1391         """Sort objects in the scene.
1392
1393         The object sorting is done accordingly to the object centers.
1394         """
1395
1396         c = self._getObjPosition(self.cameraObj)
1397
1398         by_center_pos = (lambda o1, o2:
1399                 (o1.getType() == 'Mesh' and o2.getType() == 'Mesh') and
1400                 cmp((self._getObjPosition(o1) - Vector(c)).length,
1401                     (self._getObjPosition(o2) - Vector(c)).length)
1402             )
1403
1404         # TODO: implement sorting by bounding box, if obj1.bb is inside obj2.bb,
1405         # then ob1 goes farther than obj2, useful when obj2 has holes
1406         by_bbox = None
1407
1408         Objects = scene.getChildren()
1409         Objects.sort(by_center_pos)
1410
1411         # update the scene
1412         for o in Objects:
1413             scene.unlink(o)
1414             scene.link(o)
1415
1416     def _joinMeshObjectsInScene(self, scene):
1417         """Merge all the Mesh Objects in a scene into a single Mesh Object.
1418         """
1419
1420         oList = [o for o in scene.getChildren() if o.getType()=='Mesh']
1421
1422         # FIXME: Object.join() do not work if the list contains 1 object
1423         if len(oList) == 1:
1424             return
1425
1426         mesh = Mesh.New('BigOne')
1427         bigObj = Object.New('Mesh', 'BigOne')
1428         bigObj.link(mesh)
1429
1430         scene.link(bigObj)
1431
1432         try:
1433             bigObj.join(oList)
1434         except RuntimeError:
1435             print "\nWarning! - Can't Join Objects\n"
1436             scene.unlink(bigObj)
1437             return
1438         except TypeError:
1439             print "Objects Type error?"
1440
1441         for o in oList:
1442             scene.unlink(o)
1443
1444         scene.update()
1445
1446
1447     # Per object/mesh methods
1448
1449     def _convertToRawMeshObj(self, object):
1450         """Convert geometry based object to a mesh object.
1451         """
1452         me = Mesh.New('RawMesh_'+object.name)
1453         me.getFromObject(object.name)
1454
1455         newObject = Object.New('Mesh', 'RawMesh_'+object.name)
1456         newObject.link(me)
1457
1458         # If the object has no materials set a default material
1459         if not me.materials:
1460             me.materials = [Material.New()]
1461             #for f in me.faces: f.mat = 0
1462
1463         newObject.setMatrix(object.getMatrix())
1464
1465         return newObject
1466
1467     def _doModelingTransformation(self, mesh, matrix):
1468         """Transform object coordinates to world coordinates.
1469
1470         This step is done simply applying to the object its tranformation
1471         matrix and recalculating its normals.
1472         """
1473         # XXX FIXME: blender do not transform normals in the right way when
1474         # there are negative scale values
1475         if matrix[0][0] < 0 or matrix[1][1] < 0 or matrix[2][2] < 0:
1476             print "WARNING: Negative scales, expect incorrect results!"
1477
1478         mesh.transform(matrix, True)
1479
1480     def _doBackFaceCulling(self, mesh):
1481         """Simple Backface Culling routine.
1482
1483         At this level we simply do a visibility test face by face and then
1484         select the vertices belonging to visible faces.
1485         """
1486
1487         # Select all vertices, so edges can be displayed even if there are no
1488         # faces
1489         for v in mesh.verts:
1490             v.sel = 1
1491
1492         Mesh.Mode(Mesh.SelectModes['FACE'])
1493         # Loop on faces
1494         for f in mesh.faces:
1495             f.sel = 0
1496             if self._isFaceVisible(f):
1497                 f.sel = 1
1498
1499     def _doLighting(self, mesh):
1500         """Apply an Illumination and shading model to the object.
1501
1502         The model used is the Phong one, it may be inefficient,
1503         but I'm just learning about rendering and starting from Phong seemed
1504         the most natural way.
1505         """
1506
1507         # If the mesh has vertex colors already, use them,
1508         # otherwise turn them on and do some calculations
1509         if mesh.vertexColors:
1510             return
1511         mesh.vertexColors = 1
1512
1513         materials = mesh.materials
1514
1515         camPos = self._getObjPosition(self.cameraObj)
1516
1517         # We do per-face color calculation (FLAT Shading), we can easily turn
1518         # to a per-vertex calculation if we want to implement some shading
1519         # technique. For an example see:
1520         # http://www.miralab.unige.ch/papers/368.pdf
1521         for f in mesh.faces:
1522             if not f.sel:
1523                 continue
1524
1525             mat = None
1526             if materials:
1527                 mat = materials[f.mat]
1528
1529             # A new default material
1530             if mat == None:
1531                 mat = Material.New('defMat')
1532
1533             # Check if it is a shadeless material
1534             elif mat.getMode() & Material.Modes['SHADELESS']:
1535                 I = mat.getRGBCol()
1536                 # Convert to a value between 0 and 255
1537                 tmp_col = [ int(c * 255.0) for c in I]
1538
1539                 for c in f.col:
1540                     c.r = tmp_col[0]
1541                     c.g = tmp_col[1]
1542                     c.b = tmp_col[2]
1543                     #c.a = tmp_col[3]
1544
1545                 continue
1546
1547
1548             # do vertex color calculation
1549
1550             TotDiffSpec = Vector([0.0, 0.0, 0.0])
1551
1552             for l in self.lights:
1553                 light_obj = l
1554                 light_pos = self._getObjPosition(l)
1555                 light = light_obj.getData()
1556
1557                 L = Vector(light_pos).normalize()
1558
1559                 V = (Vector(camPos) - Vector(f.cent)).normalize()
1560
1561                 N = Vector(f.no).normalize()
1562
1563                 if config.polygons['SHADING'] == 'TOON':
1564                     NL = ShadingUtils.toonShading(N*L)
1565                 else:
1566                     NL = (N*L)
1567
1568                 # Should we use NL instead of (N*L) here?
1569                 R = 2 * (N*L) * N - L
1570
1571                 Ip = light.getEnergy()
1572
1573                 # Diffuse co-efficient
1574                 kd = mat.getRef() * Vector(mat.getRGBCol())
1575                 for i in [0, 1, 2]:
1576                     kd[i] *= light.col[i]
1577
1578                 Idiff = Ip * kd * max(0, NL)
1579
1580
1581                 # Specular component
1582                 ks = mat.getSpec() * Vector(mat.getSpecCol())
1583                 ns = mat.getHardness()
1584                 Ispec = Ip * ks * pow(max(0, (V*R)), ns)
1585
1586                 TotDiffSpec += (Idiff+Ispec)
1587
1588
1589             # Ambient component
1590             Iamb = Vector(Blender.World.Get()[0].getAmb())
1591             ka = mat.getAmb()
1592
1593             # Emissive component (convert to a triplet)
1594             ki = Vector([mat.getEmit()]*3)
1595
1596             #I = ki + Iamb + (Idiff + Ispec)
1597             I = ki + (ka * Iamb) + TotDiffSpec
1598
1599
1600             # Set Alpha component
1601             I = list(I)
1602             I.append(mat.getAlpha())
1603
1604             # Clamp I values between 0 and 1
1605             I = [ min(c, 1) for c in I]
1606             I = [ max(0, c) for c in I]
1607
1608             # Convert to a value between 0 and 255
1609             tmp_col = [ int(c * 255.0) for c in I]
1610
1611             for c in f.col:
1612                 c.r = tmp_col[0]
1613                 c.g = tmp_col[1]
1614                 c.b = tmp_col[2]
1615                 c.a = tmp_col[3]
1616
1617     def _doProjection(self, mesh, projector):
1618         """Apply Viewing and Projection tranformations.
1619         """
1620
1621         for v in mesh.verts:
1622             p = projector.doProjection(v.co[:])
1623             v.co[0] = p[0]
1624             v.co[1] = p[1]
1625             v.co[2] = p[2]
1626
1627         #mesh.recalcNormals()
1628         #mesh.update()
1629
1630         # We could reeset Camera matrix, since now
1631         # we are in Normalized Viewing Coordinates,
1632         # but doung that would affect World Coordinate
1633         # processing for other objects
1634
1635         #self.cameraObj.data.type = 1
1636         #self.cameraObj.data.scale = 2.0
1637         #m = Matrix().identity()
1638         #self.cameraObj.setMatrix(m)
1639
1640     def _doViewFrustumClipping(self, mesh):
1641         """Clip faces against the View Frustum.
1642         """
1643
1644     # HSR routines
1645     def __simpleDepthSort(self, mesh):
1646         """Sort faces by the furthest vertex.
1647
1648         This simple mesthod is known also as the painter algorithm, and it
1649         solves HSR correctly only for convex meshes.
1650         """
1651
1652         #global progress
1653
1654         # The sorting requires circa n*log(n) steps
1655         n = len(mesh.faces)
1656         progress.setActivity("HSR: Painter", n*log(n))
1657
1658         by_furthest_z = (lambda f1, f2: progress.update() and
1659                 cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2])+EPS)
1660                 )
1661
1662         # FIXME: using NMesh to sort faces. We should avoid that!
1663         nmesh = NMesh.GetRaw(mesh.name)
1664
1665         # remember that _higher_ z values mean further points
1666         nmesh.faces.sort(by_furthest_z)
1667         nmesh.faces.reverse()
1668
1669         nmesh.update()
1670
1671
1672     def __newellDepthSort(self, mesh):
1673         """Newell's depth sorting.
1674
1675         """
1676         from hsrtk import *
1677
1678         #global progress
1679
1680         # Find non planar quads and convert them to triangle
1681         #for f in mesh.faces:
1682         #    f.sel = 0
1683         #    if is_nonplanar_quad(f.v):
1684         #        print "NON QUAD??"
1685         #        f.sel = 1
1686
1687
1688         # Now reselect all faces
1689         for f in mesh.faces:
1690             f.sel = 1
1691         mesh.quadToTriangle()
1692
1693         # FIXME: using NMesh to sort faces. We should avoid that!
1694         nmesh = NMesh.GetRaw(mesh.name)
1695
1696         # remember that _higher_ z values mean further points
1697         nmesh.faces.sort(by_furthest_z)
1698         nmesh.faces.reverse()
1699
1700         # Begin depth sort tests
1701
1702         # use the smooth flag to set marked faces
1703         for f in nmesh.faces:
1704             f.smooth = 0
1705
1706         facelist = nmesh.faces[:]
1707         maplist = []
1708
1709
1710         # The steps are _at_least_ equal to len(facelist), we do not count the
1711         # feces coming out from splitting!!
1712         progress.setActivity("HSR: Newell", len(facelist))
1713         #progress.setQuiet(True)
1714
1715
1716         while len(facelist):
1717             debug("\n----------------------\n")
1718             debug("len(facelits): %d\n" % len(facelist))
1719             P = facelist[0]
1720
1721             pSign = sign(P.normal[2])
1722
1723             # We can discard faces parallel to the view vector
1724             #if P.normal[2] == 0:
1725             #    facelist.remove(P)
1726             #    continue
1727
1728             split_done = 0
1729             face_marked = 0
1730
1731             for Q in facelist[1:]:
1732
1733                 debug("P.smooth: " + str(P.smooth) + "\n")
1734                 debug("Q.smooth: " + str(Q.smooth) + "\n")
1735                 debug("\n")
1736
1737                 qSign = sign(Q.normal[2])
1738                 # TODO: check also if Q is parallel??
1739
1740                 # Test 0: We need to test only those Qs whose furthest vertex
1741                 # is closer to the observer than the closest vertex of P.
1742
1743                 zP = [v.co[2] for v in P.v]
1744                 zQ = [v.co[2] for v in Q.v]
1745                 notZOverlap = min(zP) > max(zQ) + EPS
1746
1747                 if notZOverlap:
1748                     debug("\nTest 0\n")
1749                     debug("NOT Z OVERLAP!\n")
1750                     if Q.smooth == 0:
1751                         # If Q is not marked then we can safely print P
1752                         break
1753                     else:
1754                         debug("met a marked face\n")
1755                         continue
1756
1757
1758                 # Test 1: X extent overlapping
1759                 xP = [v.co[0] for v in P.v]
1760                 xQ = [v.co[0] for v in Q.v]
1761                 #notXOverlap = (max(xP) <= min(xQ)) or (max(xQ) <= min(xP))
1762                 notXOverlap = (min(xQ) >= max(xP)-EPS) or (min(xP) >= max(xQ)-EPS)
1763
1764                 if notXOverlap:
1765                     debug("\nTest 1\n")
1766                     debug("NOT X OVERLAP!\n")
1767                     continue
1768
1769
1770                 # Test 2: Y extent Overlapping
1771                 yP = [v.co[1] for v in P.v]
1772                 yQ = [v.co[1] for v in Q.v]
1773                 #notYOverlap = (max(yP) <= min(yQ)) or (max(yQ) <= min(yP))
1774                 notYOverlap = (min(yQ) >= max(yP)-EPS) or (min(yP) >= max(yQ)-EPS)
1775
1776                 if notYOverlap:
1777                     debug("\nTest 2\n")
1778                     debug("NOT Y OVERLAP!\n")
1779                     continue
1780
1781
1782                 # Test 3: P vertices are all behind the plane of Q
1783                 n = 0
1784                 for Pi in P:
1785                     d = qSign * Distance(Vector(Pi), Q)
1786                     if d <= EPS:
1787                         n += 1
1788                 pVerticesBehindPlaneQ = (n == len(P))
1789
1790                 if pVerticesBehindPlaneQ:
1791                     debug("\nTest 3\n")
1792                     debug("P BEHIND Q!\n")
1793                     continue
1794
1795
1796                 # Test 4: Q vertices in front of the plane of P
1797                 n = 0
1798                 for Qi in Q:
1799                     d = pSign * Distance(Vector(Qi), P)
1800                     if d >= -EPS:
1801                         n += 1
1802                 qVerticesInFrontPlaneP = (n == len(Q))
1803
1804                 if qVerticesInFrontPlaneP:
1805                     debug("\nTest 4\n")
1806                     debug("Q IN FRONT OF P!\n")
1807                     continue
1808
1809
1810                 # Test 5: Check if projections of polygons effectively overlap,
1811                 # in previous tests we checked only bounding boxes.
1812
1813                 if not projectionsOverlap(P, Q):
1814                     debug("\nTest 5\n")
1815                     debug("Projections do not overlap!\n")
1816                     continue
1817
1818                 # We still can't say if P obscures Q.
1819
1820                 # But if Q is marked we do a face-split trying to resolve a
1821                 # difficulty (maybe a visibility cycle).
1822                 if Q.smooth == 1:
1823                     # Split P or Q
1824                     debug("Possibly a cycle detected!\n")
1825                     debug("Split here!!\n")
1826
1827                     facelist = facesplit(P, Q, facelist, nmesh)
1828                     split_done = 1
1829                     break
1830
1831                 # The question now is: Does Q obscure P?
1832
1833
1834                 # Test 3bis: Q vertices are all behind the plane of P
1835                 n = 0
1836                 for Qi in Q:
1837                     d = pSign * Distance(Vector(Qi), P)
1838                     if d <= EPS:
1839                         n += 1
1840                 qVerticesBehindPlaneP = (n == len(Q))
1841
1842                 if qVerticesBehindPlaneP:
1843                     debug("\nTest 3bis\n")
1844                     debug("Q BEHIND P!\n")
1845
1846
1847                 # Test 4bis: P vertices in front of the plane of Q
1848                 n = 0
1849                 for Pi in P:
1850                     d = qSign * Distance(Vector(Pi), Q)
1851                     if d >= -EPS:
1852                         n += 1
1853                 pVerticesInFrontPlaneQ = (n == len(P))
1854
1855                 if pVerticesInFrontPlaneQ:
1856                     debug("\nTest 4bis\n")
1857                     debug("P IN FRONT OF Q!\n")
1858
1859
1860                 # We don't even know if Q does obscure P, so they should
1861                 # intersect each other, split one of them in two parts.
1862                 if not qVerticesBehindPlaneP and not pVerticesInFrontPlaneQ:
1863                     debug("\nSimple Intersection?\n")
1864                     debug("Test 3bis or 4bis failed\n")
1865                     debug("Split here!!2\n")
1866
1867                     facelist = facesplit(P, Q, facelist, nmesh)
1868                     split_done = 1
1869                     break
1870
1871                 facelist.remove(Q)
1872                 facelist.insert(0, Q)
1873                 Q.smooth = 1
1874                 face_marked = 1
1875                 debug("Q marked!\n")
1876                 break
1877
1878             # Write P!
1879             if split_done == 0 and face_marked == 0:
1880                 facelist.remove(P)
1881                 maplist.append(P)
1882
1883                 progress.update()
1884
1885             #if facelist == None:
1886             #    maplist = [P, Q]
1887             #    print [v.co for v in P]
1888             #    print [v.co for v in Q]
1889             #    break
1890
1891             # end of while len(facelist)
1892
1893
1894         nmesh.faces = maplist
1895         for f in nmesh.faces:
1896             f.sel = 1
1897
1898         nmesh.update()
1899
1900
1901     def _doHiddenSurfaceRemoval(self, mesh):
1902         """Do HSR for the given mesh.
1903         """
1904         if len(mesh.faces) == 0:
1905             return
1906
1907         if config.polygons['HSR'] == 'PAINTER':
1908             print "\nUsing the Painter algorithm for HSR."
1909             self.__simpleDepthSort(mesh)
1910
1911         elif config.polygons['HSR'] == 'NEWELL':
1912             print "\nUsing the Newell's algorithm for HSR."
1913             self.__newellDepthSort(mesh)
1914
1915
1916     def _doEdgesStyle(self, mesh, edgestyleSelect):
1917         """Process Mesh Edges accroding to a given selection style.
1918
1919         Examples of algorithms:
1920
1921         Contours:
1922             given an edge if its adjacent faces have the same normal (that is
1923             they are complanar), than deselect it.
1924
1925         Silhouettes:
1926             given an edge if one its adjacent faces is frontfacing and the
1927             other is backfacing, than select it, else deselect.
1928         """
1929
1930         Mesh.Mode(Mesh.SelectModes['EDGE'])
1931
1932         edge_cache = MeshUtils.buildEdgeFaceUsersCache(mesh)
1933
1934         for i,edge_faces in enumerate(edge_cache):
1935             mesh.edges[i].sel = 0
1936             if edgestyleSelect(edge_faces):
1937                 mesh.edges[i].sel = 1
1938
1939         """
1940         for e in mesh.edges:
1941
1942             e.sel = 0
1943             if edgestyleSelect(e, mesh):
1944                 e.sel = 1
1945         """
1946
1947
1948
1949 # ---------------------------------------------------------------------
1950 #
1951 ## GUI Class and Main Program
1952 #
1953 # ---------------------------------------------------------------------
1954
1955
1956 from Blender import BGL, Draw
1957 from Blender.BGL import *
1958
1959 class GUI:
1960
1961     def _init():
1962
1963         # Output Format menu
1964         output_format = config.output['FORMAT']
1965         default_value = outputWriters.keys().index(output_format)+1
1966         GUI.outFormatMenu = Draw.Create(default_value)
1967         GUI.evtOutFormatMenu = 0
1968
1969         # Animation toggle button
1970         GUI.animToggle = Draw.Create(config.output['ANIMATION'])
1971         GUI.evtAnimToggle = 1
1972
1973         # Join Objects toggle button
1974         GUI.joinObjsToggle = Draw.Create(config.output['JOIN_OBJECTS'])
1975         GUI.evtJoinObjsToggle = 2
1976
1977         # Render filled polygons
1978         GUI.polygonsToggle = Draw.Create(config.polygons['SHOW'])
1979
1980         # Shading Style menu
1981         shading_style = config.polygons['SHADING']
1982         default_value = shadingStyles.keys().index(shading_style)+1
1983         GUI.shadingStyleMenu = Draw.Create(default_value)
1984         GUI.evtShadingStyleMenu = 21
1985
1986         GUI.evtPolygonsToggle = 3
1987         # We hide the config.polygons['EXPANSION_TRICK'], for now
1988
1989         # Render polygon edges
1990         GUI.showEdgesToggle = Draw.Create(config.edges['SHOW'])
1991         GUI.evtShowEdgesToggle = 4
1992
1993         # Render hidden edges
1994         GUI.showHiddenEdgesToggle = Draw.Create(config.edges['SHOW_HIDDEN'])
1995         GUI.evtShowHiddenEdgesToggle = 5
1996
1997         # Edge Style menu
1998         edge_style = config.edges['STYLE']
1999         default_value = edgeStyles.keys().index(edge_style)+1
2000         GUI.edgeStyleMenu = Draw.Create(default_value)
2001         GUI.evtEdgeStyleMenu = 6
2002
2003         # Edge Width slider
2004         GUI.edgeWidthSlider = Draw.Create(config.edges['WIDTH'])
2005         GUI.evtEdgeWidthSlider = 7
2006
2007         # Edge Color Picker
2008         c = config.edges['COLOR']
2009         GUI.edgeColorPicker = Draw.Create(c[0]/255.0, c[1]/255.0, c[2]/255.0)
2010         GUI.evtEdgeColorPicker = 71
2011
2012         # Render Button
2013         GUI.evtRenderButton = 8
2014
2015         # Exit Button
2016         GUI.evtExitButton = 9
2017
2018     def draw():
2019
2020         # initialize static members
2021         GUI._init()
2022
2023         glClear(GL_COLOR_BUFFER_BIT)
2024         glColor3f(0.0, 0.0, 0.0)
2025         glRasterPos2i(10, 350)
2026         Draw.Text("VRM: Vector Rendering Method script. Version %s." %
2027                 __version__)
2028         glRasterPos2i(10, 335)
2029         Draw.Text("Press Q or ESC to quit.")
2030
2031         # Build the output format menu
2032         glRasterPos2i(10, 310)
2033         Draw.Text("Select the output Format:")
2034         outMenuStruct = "Output Format %t"
2035         for t in outputWriters.keys():
2036            outMenuStruct = outMenuStruct + "|%s" % t
2037         GUI.outFormatMenu = Draw.Menu(outMenuStruct, GUI.evtOutFormatMenu,
2038                 10, 285, 160, 18, GUI.outFormatMenu.val, "Choose the Output Format")
2039
2040         # Animation toggle
2041         GUI.animToggle = Draw.Toggle("Animation", GUI.evtAnimToggle,
2042                 10, 260, 160, 18, GUI.animToggle.val,
2043                 "Toggle rendering of animations")
2044
2045         # Join Objects toggle
2046         GUI.joinObjsToggle = Draw.Toggle("Join objects", GUI.evtJoinObjsToggle,
2047                 10, 235, 160, 18, GUI.joinObjsToggle.val,
2048                 "Join objects in the rendered file")
2049
2050         # Render Button
2051         Draw.Button("Render", GUI.evtRenderButton, 10, 210-25, 75, 25+18,
2052                 "Start Rendering")
2053         Draw.Button("Exit", GUI.evtExitButton, 95, 210-25, 75, 25+18, "Exit!")
2054
2055         # Rendering Styles
2056         glRasterPos2i(200, 310)
2057         Draw.Text("Rendering Style:")
2058
2059         # Render Polygons
2060         GUI.polygonsToggle = Draw.Toggle("Filled Polygons", GUI.evtPolygonsToggle,
2061                 200, 285, 160, 18, GUI.polygonsToggle.val,
2062                 "Render filled polygons")
2063
2064         if GUI.polygonsToggle.val == 1:
2065
2066             # Polygon Shading Style
2067             shadingStyleMenuStruct = "Shading Style %t"
2068             for t in shadingStyles.keys():
2069                 shadingStyleMenuStruct = shadingStyleMenuStruct + "|%s" % t.lower()
2070             GUI.shadingStyleMenu = Draw.Menu(shadingStyleMenuStruct, GUI.evtShadingStyleMenu,
2071                     200, 260, 160, 18, GUI.shadingStyleMenu.val,
2072                     "Choose the shading style")
2073
2074
2075         # Render Edges
2076         GUI.showEdgesToggle = Draw.Toggle("Show Edges", GUI.evtShowEdgesToggle,
2077                 200, 235, 160, 18, GUI.showEdgesToggle.val,
2078                 "Render polygon edges")
2079
2080         if GUI.showEdgesToggle.val == 1:
2081
2082             # Edge Style
2083             edgeStyleMenuStruct = "Edge Style %t"
2084             for t in edgeStyles.keys():
2085                 edgeStyleMenuStruct = edgeStyleMenuStruct + "|%s" % t.lower()
2086             GUI.edgeStyleMenu = Draw.Menu(edgeStyleMenuStruct, GUI.evtEdgeStyleMenu,
2087                     200, 210, 160, 18, GUI.edgeStyleMenu.val,
2088                     "Choose the edge style")
2089
2090             # Edge size
2091             GUI.edgeWidthSlider = Draw.Slider("Width: ", GUI.evtEdgeWidthSlider,
2092                     200, 185, 140, 18, GUI.edgeWidthSlider.val,
2093                     0.0, 10.0, 0, "Change Edge Width")
2094
2095             # Edge Color
2096             GUI.edgeColorPicker = Draw.ColorPicker(GUI.evtEdgeColorPicker,
2097                     342, 185, 18, 18, GUI.edgeColorPicker.val, "Choose Edge Color")
2098
2099             # Show Hidden Edges
2100             GUI.showHiddenEdgesToggle = Draw.Toggle("Show Hidden Edges",
2101                     GUI.evtShowHiddenEdgesToggle,
2102                     200, 160, 160, 18, GUI.showHiddenEdgesToggle.val,
2103                     "Render hidden edges as dashed lines")
2104
2105         glRasterPos2i(10, 160)
2106         Draw.Text("%s (c) 2006" % __author__)
2107
2108     def event(evt, val):
2109
2110         if evt == Draw.ESCKEY or evt == Draw.QKEY:
2111             Draw.Exit()
2112         else:
2113             return
2114
2115         Draw.Redraw(1)
2116
2117     def button_event(evt):
2118
2119         if evt == GUI.evtExitButton:
2120             Draw.Exit()
2121
2122         elif evt == GUI.evtOutFormatMenu:
2123             i = GUI.outFormatMenu.val - 1
2124             config.output['FORMAT']= outputWriters.keys()[i]
2125
2126         elif evt == GUI.evtAnimToggle:
2127             config.output['ANIMATION'] = bool(GUI.animToggle.val)
2128
2129         elif evt == GUI.evtJoinObjsToggle:
2130             config.output['JOIN_OBJECTS'] = bool(GUI.joinObjsToggle.val)
2131
2132         elif evt == GUI.evtPolygonsToggle:
2133             config.polygons['SHOW'] = bool(GUI.polygonsToggle.val)
2134
2135         elif evt == GUI.evtShadingStyleMenu:
2136             i = GUI.shadingStyleMenu.val - 1
2137             config.polygons['SHADING'] = shadingStyles.keys()[i]
2138
2139         elif evt == GUI.evtShowEdgesToggle:
2140             config.edges['SHOW'] = bool(GUI.showEdgesToggle.val)
2141
2142         elif evt == GUI.evtShowHiddenEdgesToggle:
2143             config.edges['SHOW_HIDDEN'] = bool(GUI.showHiddenEdgesToggle.val)
2144
2145         elif evt == GUI.evtEdgeStyleMenu:
2146             i = GUI.edgeStyleMenu.val - 1
2147             config.edges['STYLE'] = edgeStyles.keys()[i]
2148
2149         elif evt == GUI.evtEdgeWidthSlider:
2150             config.edges['WIDTH'] = float(GUI.edgeWidthSlider.val)
2151
2152         elif evt == GUI.evtEdgeColorPicker:
2153             config.edges['COLOR'] = [int(c*255.0) for c in GUI.edgeColorPicker.val]
2154
2155         elif evt == GUI.evtRenderButton:
2156             label = "Save %s" % config.output['FORMAT']
2157             # Show the File Selector
2158             global outputfile
2159             Blender.Window.FileSelector(vectorize, label, outputfile)
2160
2161         else:
2162             print "Event: %d not handled!" % evt
2163
2164         if evt:
2165             Draw.Redraw(1)
2166             #GUI.conf_debug()
2167
2168     def conf_debug():
2169         from pprint import pprint
2170         print "\nConfig"
2171         pprint(config.output)
2172         pprint(config.polygons)
2173         pprint(config.edges)
2174
2175     _init = staticmethod(_init)
2176     draw = staticmethod(draw)
2177     event = staticmethod(event)
2178     button_event = staticmethod(button_event)
2179     conf_debug = staticmethod(conf_debug)
2180
2181 # A wrapper function for the vectorizing process
2182 def vectorize(filename):
2183     """The vectorizing process is as follows:
2184
2185      - Instanciate the writer and the renderer
2186      - Render!
2187      """
2188
2189     if filename == "":
2190         print "\nERROR: invalid file name!"
2191         return
2192
2193     from Blender import Window
2194     editmode = Window.EditMode()
2195     if editmode: Window.EditMode(0)
2196
2197     actualWriter = outputWriters[config.output['FORMAT']]
2198     writer = actualWriter(filename)
2199
2200     renderer = Renderer()
2201     renderer.doRendering(writer, config.output['ANIMATION'])
2202
2203     if editmode: Window.EditMode(1)
2204
2205 # Here the main
2206 if __name__ == "__main__":
2207
2208     global progress
2209
2210     outputfile = ""
2211     basename = Blender.sys.basename(Blender.Get('filename'))
2212     if basename != "":
2213         outputfile = Blender.sys.splitext(basename)[0] + "." + str(config.output['FORMAT']).lower()
2214
2215     if Blender.mode == 'background':
2216         progress = ConsoleProgressIndicator()
2217         vectorize(outputfile)
2218     else:
2219         progress = GraphicalProgressIndicator()
2220         Draw.Register(GUI.draw, GUI.event, GUI.button_event)