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