vrm.py

   1 #!BPY
   2 """
   3 Name: 'VRM'
   4 Blender: 241
   5 Group: 'Export'
   6 Tooltip: 'Vector Rendering Method Export Script'
   7 """
   8
   9 __author__ = "Antonio Ospite"
  10 __url__ = ["blender"]
  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 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.)
  53 #   - Implement Edge coloring
  54 #   - Use multiple lighting sources in color calculation
  55 #   - Implement Shading Styles?
  56 #   - Use another representation for the 2D projection?
  57 #     Think to a way to merge adjacent polygons that have the same color.
  58 #   - Add other Vector Writers.
  59 #
  60 # ---------------------------------------------------------------------
  61 #
  62 # Changelog:
  63 #
  64 #   vrm-0.3.py  -   2006-05-19
  65 #    * First release after code restucturing.
  66 #      Now the script offers a useful set of functionalities
  67 #      and it can render animations, too.
  68 #
  69 # ---------------------------------------------------------------------
  70
  71 import Blender
  72 from Blender import Scene, Object, Mesh, NMesh, Material, Lamp, Camera
  73 from Blender.Mathutils import *
  74 from math import *
  75
  76
  77 # Some global settings
  78 PRINT_POLYGONS     = True
  79 PRINT_EDGES        = False
  80 SHOW_HIDDEN_EDGES  = False
  81
  82 EDGES_WIDTH = 0.5
  83
  84 POLYGON_EXPANSION_TRICK = True
  85
  86 RENDER_ANIMATION = False
  87
  88 # Does not work in batch mode!!
  89 #OPTIMIZE_FOR_SPACE = True
  90
  91
  92 # ---------------------------------------------------------------------
  93 #
  94 ## Projections classes
  95 #
  96 # ---------------------------------------------------------------------
  97
  98 class Projector:
  99     """Calculate the projection of an object given the camera.
 100
 101     A projector is useful to so some per-object transformation to obtain the
 102     projection of an object given the camera.
 103
 104     The main method is #doProjection# see the method description for the
 105     parameter list.
 106     """
 107
 108     def __init__(self, cameraObj, canvasRatio):
 109         """Calculate the projection matrix.
 110
 111         The projection matrix depends, in this case, on the camera settings.
 112         TAKE CARE: This projector expects vertices in World Coordinates!
 113         """
 114
 115         camera = cameraObj.getData()
 116
 117         aspect = float(canvasRatio[0])/float(canvasRatio[1])
 118         near = camera.clipStart
 119         far = camera.clipEnd
 120
 121         scale = float(camera.scale)
 122
 123         fovy = atan(0.5/aspect/(camera.lens/32))
 124         fovy = fovy * 360.0/pi
 125
 126         # What projection do we want?
 127         if camera.type:
 128             #mP = self._calcOrthoMatrix(fovy, aspect, near, far, 17) #camera.scale)
 129             mP = self._calcOrthoMatrix(fovy, aspect, near, far, scale)
 130         else:
 131             mP = self._calcPerspectiveMatrix(fovy, aspect, near, far)
 132
 133         # View transformation
 134         cam = Matrix(cameraObj.getInverseMatrix())
 135         cam.transpose()
 136
 137         mP = mP * cam
 138
 139         self.projectionMatrix = mP
 140
 141     ##
 142     # Public methods
 143     #
 144
 145     def doProjection(self, v):
 146         """Project the point on the view plane.
 147
 148         Given a vertex calculate the projection using the current projection
 149         matrix.
 150         """
 151
 152         # Note that we have to work on the vertex using homogeneous coordinates
 153         p = self.projectionMatrix * Vector(v).resize4D()
 154
 155         if p[3]>0:
 156             p[0] = p[0]/p[3]
 157             p[1] = p[1]/p[3]
 158
 159         # restore the size
 160         p[3] = 1.0
 161         p.resize3D()
 162
 163         return p
 164
 165     ##
 166     # Private methods
 167     #
 168
 169     def _calcPerspectiveMatrix(self, fovy, aspect, near, far):
 170         """Return a perspective projection matrix.
 171         """
 172
 173         top = near * tan(fovy * pi / 360.0)
 174         bottom = -top
 175         left = bottom*aspect
 176         right= top*aspect
 177         x = (2.0 * near) / (right-left)
 178         y = (2.0 * near) / (top-bottom)
 179         a = (right+left) / (right-left)
 180         b = (top+bottom) / (top - bottom)
 181         c = - ((far+near) / (far-near))
 182         d = - ((2*far*near)/(far-near))
 183
 184         m = Matrix(
 185                 [x,   0.0,    a,    0.0],
 186                 [0.0,   y,    b,    0.0],
 187                 [0.0, 0.0,    c,      d],
 188                 [0.0, 0.0, -1.0,    0.0])
 189
 190         return m
 191
 192     def _calcOrthoMatrix(self, fovy, aspect , near, far, scale):
 193         """Return an orthogonal projection matrix.
 194         """
 195
 196         # The 11 in the formula was found emiprically
 197         top = near * tan(fovy * pi / 360.0) * (scale * 11)
 198         bottom = -top
 199         left = bottom * aspect
 200         right= top * aspect
 201         rl = right-left
 202         tb = top-bottom
 203         fn = near-far
 204         tx = -((right+left)/rl)
 205         ty = -((top+bottom)/tb)
 206         tz = ((far+near)/fn)
 207
 208         m = Matrix(
 209                 [2.0/rl, 0.0,    0.0,     tx],
 210                 [0.0,    2.0/tb, 0.0,     ty],
 211                 [0.0,    0.0,    2.0/fn,  tz],
 212                 [0.0,    0.0,    0.0,    1.0])
 213
 214         return m
 215
 216
 217 # ---------------------------------------------------------------------
 218 #
 219 ## 2DObject representation class
 220 #
 221 # ---------------------------------------------------------------------
 222
 223 # TODO: a class to represent the needed properties of a 2D vector image
 224 # For now just using a [N]Mesh structure.
 225
 226
 227 # ---------------------------------------------------------------------
 228 #
 229 ## Vector Drawing Classes
 230 #
 231 # ---------------------------------------------------------------------
 232
 233 ## A generic Writer
 234
 235 class VectorWriter:
 236     """
 237     A class for printing output in a vectorial format.
 238
 239     Given a 2D representation of the 3D scene the class is responsible to
 240     write it is a vector format.
 241
 242     Every subclasses of VectorWriter must have at last the following public
 243     methods:
 244         - open(self)
 245         - close(self)
 246         - printCanvas(self, scene,
 247             doPrintPolygons=True, doPrintEdges=False, showHiddenEdges=False):
 248     """
 249
 250     def __init__(self, fileName):
 251         """Set the output file name and other properties"""
 252
 253         self.outputFileName = fileName
 254         self.file = None
 255
 256         context = Scene.GetCurrent().getRenderingContext()
 257         self.canvasSize = ( context.imageSizeX(), context.imageSizeY() )
 258
 259         self.startFrame = 1
 260         self.endFrame = 1
 261         self.animation = False
 262
 263
 264     ##
 265     # Public Methods
 266     #
 267
 268     def open(self, startFrame=1, endFrame=1):
 269         if startFrame != endFrame:
 270             self.startFrame = startFrame
 271             self.endFrame = endFrame
 272             self.animation = True
 273
 274         self.file = open(self.outputFileName, "w")
 275         print "Outputting to: ", self.outputFileName
 276
 277         return
 278
 279     def close(self):
 280         self.file.close()
 281         return
 282
 283     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
 284             showHiddenEdges=False):
 285         """This is the interface for the needed printing routine.
 286         """
 287         return
 288
 289
 290 ## SVG Writer
 291
 292 class SVGVectorWriter(VectorWriter):
 293     """A concrete class for writing SVG output.
 294     """
 295
 296     def __init__(self, fileName):
 297         """Simply call the parent Contructor.
 298         """
 299         VectorWriter.__init__(self, fileName)
 300
 301
 302     ##
 303     # Public Methods
 304     #
 305
 306     def open(self, startFrame=1, endFrame=1):
 307         """Do some initialization operations.
 308         """
 309         VectorWriter.open(self, startFrame, endFrame)
 310         self._printHeader()
 311
 312     def close(self):
 313         """Do some finalization operation.
 314         """
 315         self._printFooter()
 316
 317         # remember to call the close method of the parent
 318         VectorWriter.close(self)
 319
 320
 321     def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False,
 322             showHiddenEdges=False):
 323         """Convert the scene representation to SVG.
 324         """
 325
 326         Objects = scene.getChildren()
 327
 328         context = scene.getRenderingContext()
 329         framenumber = context.currentFrame()
 330
 331         if self.animation:
 332             framestyle = "display:none"
 333         else:
 334             framestyle = "display:block"
 335
 336         # Assign an id to this group so we can set properties on it using DOM
 337         self.file.write("<g id=\"frame%d\" style=\"%s\">\n" %
 338                 (framenumber, framestyle) )
 339
 340         for obj in Objects:
 341
 342             if(obj.getType() != 'Mesh'):
 343                 continue
 344
 345             self.file.write("<g id=\"%s\">\n" % obj.getName())
 346
 347             mesh = obj.getData(mesh=1)
 348
 349             if doPrintPolygons:
 350                 self._printPolygons(mesh)
 351
 352             if doPrintEdges:
 353                 self._printEdges(mesh, showHiddenEdges)
 354
 355             self.file.write("</g>\n")
 356
 357         self.file.write("</g>\n")
 358
 359
 360     ##
 361     # Private Methods
 362     #
 363
 364     def _calcCanvasCoord(self, v):
 365         """Convert vertex in scene coordinates to canvas coordinates.
 366         """
 367
 368         pt = Vector([0, 0, 0])
 369
 370         mW = float(self.canvasSize[0])/2.0
 371         mH = float(self.canvasSize[1])/2.0
 372
 373         # rescale to canvas size
 374         pt[0] = v.co[0]*mW + mW
 375         pt[1] = v.co[1]*mH + mH
 376         pt[2] = v.co[2]
 377
 378         # For now we want (0,0) in the top-left corner of the canvas.
 379         # Mirror and translate along y
 380         pt[1] *= -1
 381         pt[1] += self.canvasSize[1]
 382
 383         return pt
 384
 385     def _printHeader(self):
 386         """Print SVG header."""
 387
 388         self.file.write("<?xml version=\"1.0\"?>\n")
 389         self.file.write("<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n")
 390         self.file.write("\t\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n")
 391         self.file.write("<svg version=\"1.1\"\n")
 392         self.file.write("\txmlns=\"http://www.w3.org/2000/svg\"\n")
 393         self.file.write("\twidth=\"%d\" height=\"%d\" streamable=\"true\">\n\n" %
 394                 self.canvasSize)
 395
 396         if self.animation:
 397
 398             self.file.write("""\n<script><![CDATA[
 399             globalStartFrame=%d;
 400             globalEndFrame=%d;
 401
 402             /* FIXME: Use 1000 as interval as lower values gives problems */
 403             timerID = setInterval("NextFrame()", 1000);
 404             globalFrameCounter=%d;
 405
 406             function NextFrame()
 407             {
 408               currentElement  = document.getElementById('frame'+globalFrameCounter)
 409               previousElement = document.getElementById('frame'+(globalFrameCounter-1))
 410
 411               if (!currentElement)
 412               {
 413                 return;
 414               }
 415
 416               if (globalFrameCounter > globalEndFrame)
 417               {
 418                 clearInterval(timerID)
 419               }
 420               else
 421               {
 422                 if(previousElement)
 423                 {
 424                     previousElement.style.display="none";
 425                 }
 426                 currentElement.style.display="block";
 427                 globalFrameCounter++;
 428               }
 429             }
 430             \n]]></script>\n
 431             \n""" % (self.startFrame, self.endFrame, self.startFrame) )
 432
 433     def _printFooter(self):
 434         """Print the SVG footer."""
 435
 436         self.file.write("\n</svg>\n")
 437
 438     def _printPolygons(self, mesh):
 439         """Print the selected (visible) polygons.
 440         """
 441
 442         if len(mesh.faces) == 0:
 443             return
 444
 445         self.file.write("<g>\n")
 446
 447         for face in mesh.faces:
 448             if not face.sel:
 449                 continue
 450
 451             self.file.write("<polygon points=\"")
 452
 453             for v in face:
 454                 p = self._calcCanvasCoord(v)
 455                 self.file.write("%g,%g " % (p[0], p[1]))
 456
 457             # get rid of the last blank space, just cosmetics here.
 458             self.file.seek(-1, 1)
 459             self.file.write("\"\n")
 460
 461             # take as face color the first vertex color
 462             # TODO: the average of vetrex colors?
 463             if face.col:
 464                 fcol = face.col[0]
 465                 color = [fcol.r, fcol.g, fcol.b, fcol.a]
 466             else:
 467                 color = [255, 255, 255, 255]
 468
 469             # use the stroke property to alleviate the "adjacent edges" problem,
 470             # we simulate polygon expansion using borders,
 471             # see http://www.antigrain.com/svg/index.html for more info
 472             stroke_col = color
 473             stroke_width = 0.5
 474
 475             # Convert the color to the #RRGGBB form
 476             str_col = "#%02X%02X%02X" % (color[0], color[1], color[2])
 477
 478             self.file.write("\tstyle=\"fill:" + str_col + ";")
 479             if POLYGON_EXPANSION_TRICK:
 480                 self.file.write(" stroke:" + str_col + ";")
 481                 self.file.write(" stroke-width:" + str(stroke_width) + ";\n")
 482                 self.file.write(" stroke-linecap:round;stroke-linejoin:round")
 483             self.file.write("\"/>\n")
 484
 485         self.file.write("</g>\n")
 486
 487     def _printEdges(self, mesh, showHiddenEdges=False):
 488         """Print the wireframe using mesh edges.
 489         """
 490
 491         stroke_width=EDGES_WIDTH
 492         stroke_col = [0, 0, 0]
 493
 494         self.file.write("<g>\n")
 495
 496         for e in mesh.edges:
 497
 498             hidden_stroke_style = ""
 499
 500             # Consider an edge selected if both vertices are selected
 501             if e.v1.sel == 0 or e.v2.sel == 0:
 502                 if showHiddenEdges == False:
 503                     continue
 504                 else:
 505                     hidden_stroke_style = ";\n stroke-dasharray:3, 3"
 506
 507             p1 = self._calcCanvasCoord(e.v1)
 508             p2 = self._calcCanvasCoord(e.v2)
 509
 510             self.file.write("<line x1=\"%g\" y1=\"%g\" x2=\"%g\" y2=\"%g\"\n"
 511                     % ( p1[0], p1[1], p2[0], p2[1] ) )
 512             self.file.write(" style=\"stroke:rgb("+str(stroke_col[0])+","+str(stroke_col[1])+","+str(stroke_col[2])+");")
 513             self.file.write(" stroke-width:"+str(stroke_width)+";\n")
 514             self.file.write(" stroke-linecap:round;stroke-linejoin:round")
 515             self.file.write(hidden_stroke_style)
 516             self.file.write("\"/>\n")
 517
 518         self.file.write("</g>\n")
 519
 520
 521
 522 # ---------------------------------------------------------------------
 523 #
 524 ## Rendering Classes
 525 #
 526 # ---------------------------------------------------------------------
 527
 528 class Renderer:
 529     """Render a scene viewed from a given camera.
 530
 531     This class is responsible of the rendering process, transformation and
 532     projection of the objects in the scene are invoked by the renderer.
 533
 534     The rendering is done using the active camera for the current scene.
 535     """
 536
 537     def __init__(self):
 538         """Make the rendering process only for the current scene by default.
 539
 540         We will work on a copy of the scene, be sure that the current scene do
 541         not get modified in any way.
 542         """
 543
 544         # Render the current Scene, this should be a READ-ONLY property
 545         self._SCENE = Scene.GetCurrent()
 546
 547         # Use the aspect ratio of the scene rendering context
 548         context = self._SCENE.getRenderingContext()
 549
 550         aspect_ratio = float(context.imageSizeX())/float(context.imageSizeY())
 551         self.canvasRatio = (float(context.aspectRatioX())*aspect_ratio,
 552                             float(context.aspectRatioY())
 553                             )
 554
 555         # Render from the currently active camera
 556         self.cameraObj = self._SCENE.getCurrentCamera()
 557         print dir(self._SCENE)
 558
 559         # Get the list of lighting sources
 560         obj_lst = self._SCENE.getChildren()
 561         self.lights = [ o for o in obj_lst if o.getType() == 'Lamp']
 562
 563         if len(self.lights) == 0:
 564             l = Lamp.New('Lamp')
 565             lobj = Object.New('Lamp')
 566             lobj.link(l)
 567             self.lights.append(lobj)
 568
 569
 570     ##
 571     # Public Methods
 572     #
 573
 574     def doRendering(self, outputWriter, animation=False):
 575         """Render picture or animation and write it out.
 576
 577         The parameters are:
 578             - a Vector writer object that will be used to output the result.
 579             - a flag to tell if we want to render an animation or only the
 580               current frame.
 581         """
 582
 583         context = self._SCENE.getRenderingContext()
 584         currentFrame = context.currentFrame()
 585
 586         # Handle the animation case
 587         if not animation:
 588             startFrame = currentFrame
 589             endFrame = startFrame
 590             outputWriter.open()
 591         else:
 592             startFrame = context.startFrame()
 593             endFrame = context.endFrame()
 594             outputWriter.open(startFrame, endFrame)
 595
 596         # Do the rendering process frame by frame
 597         print "Start Rendering!"
 598         for f in range(startFrame, endFrame+1):
 599             context.currentFrame(f)
 600
 601             renderedScene = self.doRenderScene(self._SCENE)
 602             outputWriter.printCanvas(renderedScene,
 603                     doPrintPolygons = PRINT_POLYGONS,
 604                     doPrintEdges    = PRINT_EDGES,
 605                     showHiddenEdges = SHOW_HIDDEN_EDGES)
 606
 607             # clear the rendered scene
 608             self._SCENE.makeCurrent()
 609             Scene.unlink(renderedScene)
 610             del renderedScene
 611
 612         outputWriter.close()
 613         print "Done!"
 614         context.currentFrame(currentFrame)
 615
 616
 617     def doRenderScene(self, inputScene):
 618         """Control the rendering process.
 619
 620         Here we control the entire rendering process invoking the operation
 621         needed to transform and project the 3D scene in two dimensions.
 622         """
 623
 624         # Use some temporary workspace, a full copy of the scene
 625         workScene = inputScene.copy(2)
 626
 627         # Get a projector for this scene.
 628         # NOTE: the projector wants object in world coordinates,
 629         # so we should apply modelview transformations _before_
 630         # projection transformations
 631         proj = Projector(self.cameraObj, self.canvasRatio)
 632
 633         # global processing of the scene
 634
 635         self._doConvertGeometricObjToMesh(workScene)
 636
 637         self._doSceneClipping(workScene)
 638
 639         # FIXME: does not work in batch mode!
 640         #if OPTIMIZE_FOR_SPACE:
 641         #    self._joinMeshObjectsInScene(workScene)
 642
 643         self._doSceneDepthSorting(workScene)
 644
 645         # Per object activities
 646
 647         Objects = workScene.getChildren()
 648         for obj in Objects:
 649
 650             if obj.getType() != 'Mesh':
 651                 print "Only Mesh supported! - Skipping type:", obj.getType()
 652                 continue
 653
 654             print "Rendering: ", obj.getName()
 655
 656             mesh = obj.data
 657
 658             self._doModelToWorldCoordinates(mesh, obj.matrix)
 659
 660             self._doObjectDepthSorting(mesh)
 661
 662             self._doBackFaceCulling(mesh)
 663
 664             self._doColorAndLighting(mesh)
 665
 666             # TODO: 'style' can be a function that determine
 667             # if an edge should be showed?
 668             self._doEdgesStyle(mesh, style=None)
 669
 670             self._doProjection(mesh, proj)
 671
 672             # Update the object data, important! :)
 673             mesh.update()
 674
 675         return workScene
 676
 677
 678     ##
 679     # Private Methods
 680     #
 681
 682     # Utility methods
 683
 684     def _getObjPosition(self, obj):
 685         """Return the obj position in World coordinates.
 686         """
 687         return obj.matrix.translationPart()
 688
 689     def _cameraViewDirection(self):
 690         """Get the View Direction form the camera matrix.
 691         """
 692         return Vector(self.cameraObj.matrix[2]).resize3D()
 693
 694
 695     # Faces methods
 696
 697     def _isFaceVisible(self, face):
 698         """Determine if a face of an object is visible from the current camera.
 699
 700         The view vector is calculated from the camera location and one of the
 701         vertices of the face (expressed in World coordinates, after applying
 702         modelview transformations).
 703
 704         After those transformations we determine if a face is visible by
 705         computing the angle between the face normal and the view vector, this
 706         angle has to be between -90 and 90 degrees for the face to be visible.
 707         This corresponds somehow to the dot product between the two, if it
 708         results > 0 then the face is visible.
 709
 710         There is no need to normalize those vectors since we are only interested in
 711         the sign of the cross product and not in the product value.
 712
 713         NOTE: here we assume the face vertices are in WorldCoordinates, so
 714         please transform the object _before_ doing the test.
 715         """
 716
 717         normal = Vector(face.no)
 718         camPos = self._getObjPosition(self.cameraObj)
 719         view_vect = None
 720
 721         # View Vector in orthographics projections is the view Direction of
 722         # the camera
 723         if self.cameraObj.data.getType() == 1:
 724             view_vect = self._cameraViewDirection()
 725
 726         # View vector in perspective projections can be considered as
 727         # the difference between the camera position and one point of
 728         # the face, we choose the farthest point from the camera.
 729         if self.cameraObj.data.getType() == 0:
 730             vv = max( [ ((camPos - Vector(v.co)).length, (camPos - Vector(v.co))) for v in face] )
 731             view_vect = vv[1]
 732
 733         # if d > 0 the face is visible from the camera
 734         d = view_vect * normal
 735
 736         if d > 0:
 737             return True
 738         else:
 739             return False
 740
 741
 742     # Scene methods
 743
 744     def _doConvertGeometricObjToMesh(self, scene):
 745         """Convert all "geometric" objects to mesh ones.
 746         """
 747         geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text']
 748
 749         Objects = scene.getChildren()
 750         objList = [ o for o in Objects if o.getType() in geometricObjTypes ]
 751         for obj in objList:
 752             old_obj = obj
 753             obj = self._convertToRawMeshObj(obj)
 754             scene.link(obj)
 755             scene.unlink(old_obj)
 756
 757             # Mesh Cleanup
 758             me = obj.getData(mesh=1)
 759             for f in me.faces: f.sel = 1;
 760             for v in me.verts: v.sel = 1;
 761             me.remDoubles(0)
 762             me.triangleToQuad()
 763             me.recalcNormals()
 764             me.update()
 765
 766     def _doSceneClipping(self, scene):
 767         """Clip objects against the View Frustum.
 768
 769         For now clip away only objects according to their center position.
 770         """
 771
 772         cpos = self._getObjPosition(self.cameraObj)
 773         view_vect = self._cameraViewDirection()
 774
 775         near = self.cameraObj.data.clipStart
 776         far  = self.cameraObj.data.clipEnd
 777
 778         aspect = float(self.canvasRatio[0])/float(self.canvasRatio[1])
 779         fovy = atan(0.5/aspect/(self.cameraObj.data.lens/32))
 780         fovy = fovy * 360.0/pi
 781
 782         Objects = scene.getChildren()
 783         for o in Objects:
 784             if o.getType() != 'Mesh': continue;
 785
 786             obj_vect = Vector(cpos) - self._getObjPosition(o)
 787
 788             d = obj_vect*view_vect
 789             theta = AngleBetweenVecs(obj_vect, view_vect)
 790
 791             # if the object is outside the view frustum, clip it away
 792             if (d < near) or (d > far) or (theta > fovy):
 793                 scene.unlink(o)
 794
 795     def _doSceneDepthSorting(self, scene):
 796         """Sort objects in the scene.
 797
 798         The object sorting is done accordingly to the object centers.
 799         """
 800
 801         c = self._getObjPosition(self.cameraObj)
 802
 803         by_center_pos = (lambda o1, o2:
 804                 (o1.getType() == 'Mesh' and o2.getType() == 'Mesh') and
 805                 cmp((self._getObjPosition(o1) - Vector(c)).length,
 806                     (self._getObjPosition(o2) - Vector(c)).length)
 807             )
 808
 809         # TODO: implement sorting by bounding box, if obj1.bb is inside obj2.bb,
 810         # then ob1 goes farther than obj2, useful when obj2 has holes
 811         by_bbox = None
 812
 813         Objects = scene.getChildren()
 814         Objects.sort(by_center_pos)
 815
 816         # update the scene
 817         for o in Objects:
 818             scene.unlink(o)
 819             scene.link(o)
 820
 821     def _joinMeshObjectsInScene(self, scene):
 822         """Merge all the Mesh Objects in a scene into a single Mesh Object.
 823         """
 824         mesh = Mesh.New()
 825         bigObj = Object.New('Mesh', 'BigOne')
 826         bigObj.link(mesh)
 827
 828         oList = [o for o in scene.getChildren() if o.getType()=='Mesh']
 829         bigObj.join(oList)
 830         scene.link(bigObj)
 831         for o in oList:
 832             scene.unlink(o)
 833
 834         scene.update()
 835
 836
 837     # Per object methods
 838
 839     def _convertToRawMeshObj(self, object):
 840         """Convert geometry based object to a mesh object.
 841         """
 842         me = Mesh.New('RawMesh_'+object.name)
 843         me.getFromObject(object.name)
 844
 845         newObject = Object.New('Mesh', 'RawMesh_'+object.name)
 846         newObject.link(me)
 847
 848         # If the object has no materials set a default material
 849         if not me.materials:
 850             me.materials = [Material.New()]
 851             #for f in me.faces: f.mat = 0
 852
 853         newObject.setMatrix(object.getMatrix())
 854
 855         return newObject
 856
 857     def _doModelToWorldCoordinates(self, mesh, matrix):
 858         """Transform object coordinates to world coordinates.
 859
 860         This step is done simply applying to the object its tranformation
 861         matrix and recalculating its normals.
 862         """
 863         mesh.transform(matrix, True)
 864
 865     def _doObjectDepthSorting(self, mesh):
 866         """Sort faces in an object.
 867
 868         The faces in the object are sorted following the distance of the
 869         vertices from the camera position.
 870         """
 871         c = self._getObjPosition(self.cameraObj)
 872
 873         # hackish sorting of faces
 874
 875         # Sort faces according to the max distance from the camera
 876         by_max_vert_dist = (lambda f1, f2:
 877                 cmp(max([(Vector(v.co)-Vector(c)).length for v in f1]),
 878                     max([(Vector(v.co)-Vector(c)).length for v in f2])))
 879
 880         # Sort faces according to the min distance from the camera
 881         by_min_vert_dist = (lambda f1, f2:
 882                 cmp(min([(Vector(v.co)-Vector(c)).length for v in f1]),
 883                     min([(Vector(v.co)-Vector(c)).length for v in f2])))
 884
 885         # Sort faces according to the avg distance from the camera
 886         by_avg_vert_dist = (lambda f1, f2:
 887                 cmp(sum([(Vector(v.co)-Vector(c)).length for v in f1])/len(f1),
 888                     sum([(Vector(v.co)-Vector(c)).length for v in f2])/len(f2)))
 889
 890         mesh.faces.sort(by_max_vert_dist)
 891         mesh.faces.reverse()
 892
 893     def _doBackFaceCulling(self, mesh):
 894         """Simple Backface Culling routine.
 895
 896         At this level we simply do a visibility test face by face and then
 897         select the vertices belonging to visible faces.
 898         """
 899
 900         # Select all vertices, so edges can be displayed even if there are no
 901         # faces
 902         for v in mesh.verts:
 903             v.sel = 1
 904
 905         Mesh.Mode(Mesh.SelectModes['FACE'])
 906         # Loop on faces
 907         for f in mesh.faces:
 908             f.sel = 0
 909             if self._isFaceVisible(f):
 910                 f.sel = 1
 911
 912         # Is this the correct way to propagate the face selection info to the
 913         # vertices belonging to a face ??
 914         # TODO: Using the Mesh module this should come for free. Right?
 915         Mesh.Mode(Mesh.SelectModes['VERTEX'])
 916         for f in mesh.faces:
 917             if not f.sel:
 918                 for v in f: v.sel = 0;
 919
 920         for f in mesh.faces:
 921             if f.sel:
 922                 for v in f: v.sel = 1;
 923
 924     def _doColorAndLighting(self, mesh):
 925         """Apply an Illumination model to the object.
 926
 927         The Illumination model used is the Phong one, it may be inefficient,
 928         but I'm just learning about rendering and starting from Phong seemed
 929         the most natural way.
 930         """
 931
 932         # If the mesh has vertex colors already, use them,
 933         # otherwise turn them on and do some calculations
 934         if mesh.hasVertexColours():
 935             return
 936         mesh.hasVertexColours(True)
 937
 938         materials = mesh.materials
 939
 940         # TODO: use multiple lighting sources
 941         light_obj = self.lights[0]
 942         light_pos = self._getObjPosition(light_obj)
 943         light = light_obj.data
 944
 945         camPos = self._getObjPosition(self.cameraObj)
 946
 947         # We do per-face color calculation (FLAT Shading), we can easily turn
 948         # to a per-vertex calculation if we want to implement some shading
 949         # technique. For an example see:
 950         # http://www.miralab.unige.ch/papers/368.pdf
 951         for f in mesh.faces:
 952             if not f.sel:
 953                 continue
 954
 955             mat = None
 956             if materials:
 957                 mat = materials[f.mat]
 958
 959             # A new default material
 960             if mat == None:
 961                 mat = Material.New('defMat')
 962
 963             L = Vector(light_pos).normalize()
 964
 965             V = (Vector(camPos) - Vector(f.v[0].co)).normalize()
 966
 967             N = Vector(f.no).normalize()
 968
 969             R = 2 * (N*L) * N - L
 970
 971             # TODO: Attenuation factor (not used for now)
 972             a0 = 1; a1 = 0.0; a2 = 0.0
 973             d = (Vector(f.v[0].co) - Vector(light_pos)).length
 974             fd = min(1, 1.0/(a0 + a1*d + a2*d*d))
 975
 976             # Ambient component
 977             Ia = 1.0
 978             ka = mat.getAmb() * Vector([0.1, 0.1, 0.1])
 979             Iamb = Ia * ka
 980
 981             # Diffuse component (add light.col for kd)
 982             kd = mat.getRef() * Vector(mat.getRGBCol())
 983             Ip = light.getEnergy()
 984             Idiff = Ip * kd * (N*L)
 985
 986             # Specular component
 987             ks = mat.getSpec() * Vector(mat.getSpecCol())
 988             ns = mat.getHardness()
 989             Ispec = Ip * ks * pow((V * R), ns)
 990
 991             # Emissive component
 992             ki = Vector([mat.getEmit()]*3)
 993
 994             I = ki + Iamb + Idiff + Ispec
 995
 996             # Clamp I values between 0 and 1
 997             I = [ min(c, 1) for c in I]
 998             I = [ max(0, c) for c in I]
 999             tmp_col = [ int(c * 255.0) for c in I]
1000
1001             vcol = NMesh.Col(tmp_col[0], tmp_col[1], tmp_col[2], 255)
1002             f.col = []
1003             for v in f.v:
1004                 f.col.append(vcol)
1005
1006     def _doEdgesStyle(self, mesh, style):
1007         """Process Mesh Edges.
1008
1009         Examples of algorithms:
1010
1011         Contours:
1012             given an edge if its adjacent faces have the same normal (that is
1013             they are complanar), than deselect it.
1014
1015         Silhouettes:
1016             given an edge if one its adjacent faces is frontfacing and the
1017             other is backfacing, than select it, else deselect.
1018         """
1019         #print "\tTODO: _doEdgeStyle()"
1020         return
1021
1022     def _doProjection(self, mesh, projector):
1023         """Calculate the Projection for the object.
1024         """
1025         # TODO: maybe using the object.transform() can be faster?
1026
1027         for v in mesh.verts:
1028             p = projector.doProjection(v.co)
1029             v.co[0] = p[0]
1030             v.co[1] = p[1]
1031             v.co[2] = p[2]
1032
1033
1034
1035 # ---------------------------------------------------------------------
1036 #
1037 ## Main Program
1038 #
1039 # ---------------------------------------------------------------------
1040
1041 def vectorize(filename):
1042     """The vectorizing process is as follows:
1043
1044      - Instanciate the writer and the renderer
1045      - Render!
1046      """
1047     from Blender import Window
1048     editmode = Window.EditMode()
1049     if editmode: Window.EditMode(0)
1050
1051     writer = SVGVectorWriter(filename)
1052
1053     renderer = Renderer()
1054     renderer.doRendering(writer, RENDER_ANIMATION)
1055
1056     if editmode: Window.EditMode(1)
1057
1058 def vectorize_gui(filename):
1059     """Draw the gui.
1060
1061     I would like to keep that simple, really.
1062     """
1063     Blender.Window.FileSelector (vectorize, 'Save SVG', filename)
1064     Blender.Redraw()
1065
1066
1067 # Here the main
1068 if __name__ == "__main__":
1069
1070     basename = Blender.sys.basename(Blender.Get('filename'))
1071     outputfile = Blender.sys.splitext(basename)[0]+".svg"
1072
1073     # with this trick we can run the script in batch mode
1074     try:
1075         vectorize_gui(outputfile)
1076     except:
1077         vectorize(outputfile)