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