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