vrm.py

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