X-Git-Url: https://git.ao2.it/vrm.git/blobdiff_plain/cb636907756fdaa87a409240bbebfda832bca34a..d8063a0d4fb1d4448857006369dd02c3d30c8df6:/vrm.py?ds=sidebyside diff --git a/vrm.py b/vrm.py index 69099c4..b3aac25 100755 --- a/vrm.py +++ b/vrm.py @@ -2,12 +2,12 @@ """ Name: 'VRM' Blender: 241 -Group: 'Export' -Tooltip: 'Vector Rendering Method Export Script' +Group: 'Render' +Tooltip: 'Vector Rendering Method script' """ __author__ = "Antonio Ospite" -__url__ = ["blender"] +__url__ = ["http://vrm.projects.blender.org"] __version__ = "0.3" __bpydoc__ = """\ @@ -43,18 +43,21 @@ __bpydoc__ = """\ # # Things TODO for a next release: # - Switch to the Mesh structure, should be considerably faster -# (partially done, but cannot sort faces, yet) +# (partially done, but with Mesh we cannot sort faces, yet) # - Use a better depth sorting algorithm # - Review how selections are made (this script uses selection states of # primitives to represent visibility infos) -# - Implement Clipping and do handle object intersections -# - Implement Edge Styles (silhouettes, contours, etc.) +# - Implement clipping of primitives and do handle object intersections. +# (for now only clipping for whole objects is supported). +# - Implement Edge Styles (silhouettes, contours, etc.) (partially done). # - Implement Edge coloring # - Use multiple lighting sources in color calculation -# - Implement Shading Styles? -# - Use another representation for the 2D projection? +# - Implement Shading Styles? (for now we use Flat Shading). +# - Use a data structure other than Mesh to represent the 2D image? # Think to a way to merge adjacent polygons that have the same color. -# - Add other Vector Writers. +# Or a way to use paths for silhouettes and contours. +# - Add Vector Writers other that SVG. +# - Consider SMIL for animation handling instead of ECMA Script? # # --------------------------------------------------------------------- # @@ -75,17 +78,81 @@ from math import * # Some global settings PRINT_POLYGONS = True -PRINT_EDGES = False -SHOW_HIDDEN_EDGES = False +POLYGON_EXPANSION_TRICK = True +PRINT_EDGES = True +SHOW_HIDDEN_EDGES = False +#EDGE_STYLE = 'normal' +EDGE_STYLE = 'silhouette' EDGES_WIDTH = 0.5 -POLYGON_EXPANSION_TRICK = True - RENDER_ANIMATION = False -# Do not work for now! -OPTIMIZE_FOR_SPACE = False +OPTIMIZE_FOR_SPACE = True + +OUTPUT_FORMAT = 'SVG' + + +# --------------------------------------------------------------------- +# +## Utility Mesh class +# +# --------------------------------------------------------------------- +class MeshUtils: + def __init__(self): + return + + def getEdgeAdjacentFaces(self, edge, mesh): + """Get the faces adjacent to a given edge. + + There can be 0, 1 or more (usually 2) faces adjacent to an edge. + """ + adjface_list = [] + + for f in mesh.faces: + if (edge.v1 in f.v) and (edge.v2 in f.v): + adjface_list.append(f) + + return adjface_list + + def isVisibleEdge(self, e, mesh): + """Normal edge selection rule. + + An edge is visible if _any_ of its adjacent faces is selected. + Note: if the edge has no adjacent faces we want to show it as well, + useful for "edge only" portion of objects. + """ + + adjacent_faces = self.getEdgeAdjacentFaces(e, mesh) + + if len(adjacent_faces) == 0: + return True + + selected_faces = [f for f in adjacent_faces if f.sel] + + if len(selected_faces) != 0: + return True + else: + return False + + def isSilhouetteEdge(self, e, mesh): + """Silhuette selection rule. + + An edge is a silhuette edge if it is shared by two faces with + different selection status or if it is a boundary edge of a selected + face. + """ + + adjacent_faces = self.getEdgeAdjacentFaces(e, mesh) + + if ((len(adjacent_faces) == 1 and adjacent_faces[0].sel == 1) or + (len(adjacent_faces) == 2 and + adjacent_faces[0].sel != adjacent_faces[1].sel) + ): + return True + else: + return False + # --------------------------------------------------------------------- @@ -129,7 +196,6 @@ class Projector: else: mP = self._calcPerspectiveMatrix(fovy, aspect, near, far) - # View transformation cam = Matrix(cameraObj.getInverseMatrix()) cam.transpose() @@ -214,9 +280,10 @@ class Projector: return m + # --------------------------------------------------------------------- # -## 2DObject representation class +## 2D Object representation class # # --------------------------------------------------------------------- @@ -293,10 +360,10 @@ class SVGVectorWriter(VectorWriter): """A concrete class for writing SVG output. """ - def __init__(self, file): + def __init__(self, fileName): """Simply call the parent Contructor. """ - VectorWriter.__init__(self, file) + VectorWriter.__init__(self, fileName) ## @@ -314,6 +381,9 @@ class SVGVectorWriter(VectorWriter): """ self._printFooter() + # remember to call the close method of the parent + VectorWriter.close(self) + def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False, showHiddenEdges=False): @@ -443,7 +513,7 @@ class SVGVectorWriter(VectorWriter): for face in mesh.faces: if not face.sel: - continue + continue self.file.write("\n") @@ -491,8 +571,9 @@ class SVGVectorWriter(VectorWriter): hidden_stroke_style = "" - # Consider an edge selected if both vertices are selected - if e.v1.sel == 0 or e.v2.sel == 0: + # We consider an edge visible if _both_ its vertices are selected, + # hence an edge is hidden if _any_ of its vertices is deselected. + if e.sel == 0: if showHiddenEdges == False: continue else: @@ -568,7 +649,7 @@ class Renderer: """Render picture or animation and write it out. The parameters are: - - a Vector writer object than will be used to output the result. + - a Vector writer object that will be used to output the result. - a flag to tell if we want to render an animation or only the current frame. """ @@ -623,52 +704,54 @@ class Renderer: # projection transformations proj = Projector(self.cameraObj, self.canvasRatio) + # global processing of the scene + + self._doConvertGeometricObjToMesh(workScene) + + self._doSceneClipping(workScene) - # Convert geometric object types to mesh Objects - geometricObjTypes = ['Mesh', 'Surf', 'Curve'] # TODO: add the Text type - Objects = workScene.getChildren() - objList = [ o for o in Objects if o.getType() in geometricObjTypes ] - for obj in objList: - old_obj = obj - obj = self._convertToRawMeshObj(obj) - workScene.link(obj) - workScene.unlink(old_obj) + # XXX: Joining objects does not work in batch mode!! + # Do not touch the following if, please :) + + global OPTIMIZE_FOR_SPACE + if Blender.mode == 'background': + print "\nWARNING! Joining objects not supported in background mode!\n" + OPTIMIZE_FOR_SPACE = False - # FIXME: does not work!!, Blender segfaults on joins if OPTIMIZE_FOR_SPACE: self._joinMeshObjectsInScene(workScene) - - # global processing of the scene - self._doClipping() self._doSceneDepthSorting(workScene) # Per object activities - Objects = workScene.getChildren() + Objects = workScene.getChildren() for obj in Objects: - if obj.getType() not in geometricObjTypes: - print "Only geometric Objects supported! - Skipping type:", obj.getType() + if obj.getType() != 'Mesh': + print "Only Mesh supported! - Skipping type:", obj.getType() continue print "Rendering: ", obj.getName() - mesh = obj.data + mesh = obj.getData() self._doModelToWorldCoordinates(mesh, obj.matrix) self._doObjectDepthSorting(mesh) + # We use both Mesh and NMesh because for depth sorting we change + # face order and Mesh class don't let us to do that. + mesh.update() + mesh = obj.getData(mesh=1) + self._doBackFaceCulling(mesh) self._doColorAndLighting(mesh) - # TODO: 'style' can be a function that determine - # if an edge should be showed? - self._doEdgesStyle(mesh, style=None) + self._doEdgesStyle(mesh, edgeSelectionStyles[EDGE_STYLE]) self._doProjection(mesh, proj) @@ -684,19 +767,15 @@ class Renderer: # Utility methods - def _worldPosition(self, obj): + def _getObjPosition(self, obj): """Return the obj position in World coordinates. """ return obj.matrix.translationPart() - def _cameraWorldPosition(self): - """Return the camera position in World coordinates. - - This trick is needed when the camera follows a path and then - camera.loc does not correspond to the current real position of the - camera in the world. + def _cameraViewDirection(self): + """Get the View Direction form the camera matrix. """ - return self._worldPosition(self.cameraObj) + return Vector(self.cameraObj.matrix[2]).resize3D() # Faces methods @@ -722,25 +801,20 @@ class Renderer: """ normal = Vector(face.no) - c = self._cameraWorldPosition() - - # View vector in orthographics projections can be considered simply as the - # camera position - view_vect = Vector(c) - #if self.cameraObj.data.getType() == 1: - # view_vect = Vector(c) - - # View vector as in perspective projections - # it is the difference between the camera position and one point of - # the face, we choose the farthest point. - # TODO: make the code more pythonic :) + camPos = self._getObjPosition(self.cameraObj) + view_vect = None + + # View Vector in orthographics projections is the view Direction of + # the camera + if self.cameraObj.data.getType() == 1: + view_vect = self._cameraViewDirection() + + # View vector in perspective projections can be considered as + # the difference between the camera position and one point of + # the face, we choose the farthest point from the camera. if self.cameraObj.data.getType() == 0: - max_len = 0 - for vect in face: - vv = Vector(c) - Vector(vect.co) - if vv.length > max_len: - max_len = vv.length - view_vect = vv + vv = max( [ ((camPos - Vector(v.co)).length, (camPos - Vector(v.co))) for v in face] ) + view_vect = vv[1] # if d > 0 the face is visible from the camera d = view_vect * normal @@ -753,11 +827,61 @@ class Renderer: # Scene methods - def _doClipping(self): - """Clip object against the View Frustum. + def _doConvertGeometricObjToMesh(self, scene): + """Convert all "geometric" objects to mesh ones. """ - print "TODO: _doClipping()" - return + geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text'] + + Objects = scene.getChildren() + objList = [ o for o in Objects if o.getType() in geometricObjTypes ] + for obj in objList: + old_obj = obj + obj = self._convertToRawMeshObj(obj) + scene.link(obj) + scene.unlink(old_obj) + + + # XXX Workaround for Text and Curve which have some normals + # inverted when they are converted to Mesh, REMOVE that when + # blender will fix that!! + if old_obj.getType() in ['Curve', 'Text']: + me = obj.getData(mesh=1) + for f in me.faces: f.sel = 1; + for v in me.verts: v.sel = 1; + me.remDoubles(0) + me.triangleToQuad() + me.recalcNormals() + me.update() + + + def _doSceneClipping(self, scene): + """Clip objects against the View Frustum. + + For now clip away only objects according to their center position. + """ + + cpos = self._getObjPosition(self.cameraObj) + view_vect = self._cameraViewDirection() + + near = self.cameraObj.data.clipStart + far = self.cameraObj.data.clipEnd + + aspect = float(self.canvasRatio[0])/float(self.canvasRatio[1]) + fovy = atan(0.5/aspect/(self.cameraObj.data.lens/32)) + fovy = fovy * 360.0/pi + + Objects = scene.getChildren() + for o in Objects: + if o.getType() != 'Mesh': continue; + + obj_vect = Vector(cpos) - self._getObjPosition(o) + + d = obj_vect*view_vect + theta = AngleBetweenVecs(obj_vect, view_vect) + + # if the object is outside the view frustum, clip it away + if (d < near) or (d > far) or (theta > fovy): + scene.unlink(o) def _doSceneDepthSorting(self, scene): """Sort objects in the scene. @@ -765,40 +889,41 @@ class Renderer: The object sorting is done accordingly to the object centers. """ - c = self._cameraWorldPosition() + c = self._getObjPosition(self.cameraObj) - Objects = scene.getChildren() + by_center_pos = (lambda o1, o2: + (o1.getType() == 'Mesh' and o2.getType() == 'Mesh') and + cmp((self._getObjPosition(o1) - Vector(c)).length, + (self._getObjPosition(o2) - Vector(c)).length) + ) - #Objects.sort(lambda obj1, obj2: - # cmp((Vector(obj1.loc) - Vector(c)).length, - # (Vector(obj2.loc) - Vector(c)).length - # ) - # ) + # TODO: implement sorting by bounding box, if obj1.bb is inside obj2.bb, + # then ob1 goes farther than obj2, useful when obj2 has holes + by_bbox = None - Objects.sort(lambda obj1, obj2: - cmp((self._worldPosition(obj1) - Vector(c)).length, - (self._worldPosition(obj2) - Vector(c)).length - ) - ) + Objects = scene.getChildren() + Objects.sort(by_center_pos) # update the scene for o in Objects: scene.unlink(o) scene.link(o) - def _joinMeshObjectsInScene(self, scene): """Merge all the Mesh Objects in a scene into a single Mesh Object. """ + mesh = Mesh.New() bigObj = Object.New('Mesh', 'BigOne') + bigObj.link(mesh) + oList = [o for o in scene.getChildren() if o.getType()=='Mesh'] - print "Before join", oList bigObj.join(oList) - print "After join" scene.link(bigObj) for o in oList: scene.unlink(o) + scene.update() + # Per object methods @@ -811,6 +936,11 @@ class Renderer: newObject = Object.New('Mesh', 'RawMesh_'+object.name) newObject.link(me) + # If the object has no materials set a default material + if not me.materials: + me.materials = [Material.New()] + #for f in me.faces: f.mat = 0 + newObject.setMatrix(object.getMatrix()) return newObject @@ -829,23 +959,26 @@ class Renderer: The faces in the object are sorted following the distance of the vertices from the camera position. """ - c = self._cameraWorldPosition() + c = self._getObjPosition(self.cameraObj) # hackish sorting of faces - mesh.faces.sort( - lambda f1, f2: - # Sort faces according to the min distance from the camera - #cmp(min([(Vector(v.co)-Vector(c)).length for v in f1]), - # min([(Vector(v.co)-Vector(c)).length for v in f2]))) - # Sort faces according to the max distance from the camera + # Sort faces according to the max distance from the camera + by_max_vert_dist = (lambda f1, f2: cmp(max([(Vector(v.co)-Vector(c)).length for v in f1]), max([(Vector(v.co)-Vector(c)).length for v in f2]))) - - # Sort faces according to the avg distance from the camera - #cmp(sum([(Vector(v.co)-Vector(c)).length for v in f1])/len(f1), - # sum([(Vector(v.co)-Vector(c)).length for v in f2])/len(f2))) + + # Sort faces according to the min distance from the camera + by_min_vert_dist = (lambda f1, f2: + cmp(min([(Vector(v.co)-Vector(c)).length for v in f1]), + min([(Vector(v.co)-Vector(c)).length for v in f2]))) + + # Sort faces according to the avg distance from the camera + by_avg_vert_dist = (lambda f1, f2: + cmp(sum([(Vector(v.co)-Vector(c)).length for v in f1])/len(f1), + sum([(Vector(v.co)-Vector(c)).length for v in f2])/len(f2))) + mesh.faces.sort(by_max_vert_dist) mesh.faces.reverse() def _doBackFaceCulling(self, mesh): @@ -855,7 +988,8 @@ class Renderer: select the vertices belonging to visible faces. """ - # Select all vertices, so edges without faces can be displayed + # Select all vertices, so edges can be displayed even if there are no + # faces for v in mesh.verts: v.sel = 1 @@ -868,17 +1002,15 @@ class Renderer: # Is this the correct way to propagate the face selection info to the # vertices belonging to a face ?? - # TODO: Using the Mesh class this should come for free. Right? - Mesh.Mode(Mesh.SelectModes['VERTEX']) - for f in mesh.faces: - if not f.sel: - for v in f: - v.sel = 0 + # TODO: Using the Mesh module this should come for free. Right? + #Mesh.Mode(Mesh.SelectModes['VERTEX']) + #for f in mesh.faces: + # if not f.sel: + # for v in f: v.sel = 0; - for f in mesh.faces: - if f.sel: - for v in f: - v.sel = 1 + #for f in mesh.faces: + # if f.sel: + # for v in f: v.sel = 1; def _doColorAndLighting(self, mesh): """Apply an Illumination model to the object. @@ -890,18 +1022,18 @@ class Renderer: # If the mesh has vertex colors already, use them, # otherwise turn them on and do some calculations - if mesh.hasVertexColours(): + if mesh.vertexColors: return - mesh.hasVertexColours(True) + mesh.vertexColors = 1 materials = mesh.materials # TODO: use multiple lighting sources light_obj = self.lights[0] - light_pos = self._worldPosition(light_obj) + light_pos = self._getObjPosition(light_obj) light = light_obj.data - camPos = self._cameraWorldPosition() + camPos = self._getObjPosition(self.cameraObj) # We do per-face color calculation (FLAT Shading), we can easily turn # to a per-vertex calculation if we want to implement some shading @@ -916,7 +1048,7 @@ class Renderer: mat = materials[f.mat] # A new default material - if not mat: + if mat == None: mat = Material.New('defMat') L = Vector(light_pos).normalize() @@ -952,26 +1084,44 @@ class Renderer: I = ki + Iamb + Idiff + Ispec + # Set Alpha component + I = list(I) + I.append(mat.getAlpha()) + # Clamp I values between 0 and 1 I = [ min(c, 1) for c in I] I = [ max(0, c) for c in I] tmp_col = [ int(c * 255.0) for c in I] - vcol = NMesh.Col(tmp_col[0], tmp_col[1], tmp_col[2], 255) - f.col = [] - for v in f.v: - f.col.append(vcol) + for c in f.col: + c.r = tmp_col[0] + c.g = tmp_col[1] + c.b = tmp_col[2] + c.a = tmp_col[3] - def _doEdgesStyle(self, mesh, style): - """Process Mesh Edges. (For now copy the edge data, in next version it - can be a place where recognize silouhettes and/or contours). + def _doEdgesStyle(self, mesh, edgestyleSelect): + """Process Mesh Edges accroding to a given selection style. - input: an edge list - return: a processed edge list + Examples of algorithms: + + Contours: + given an edge if its adjacent faces have the same normal (that is + they are complanar), than deselect it. + + Silhouettes: + given an edge if one its adjacent faces is frontfacing and the + other is backfacing, than select it, else deselect. """ - #print "\tTODO: _doEdgeStyle()" - return + Mesh.Mode(Mesh.SelectModes['EDGE']) + + for e in mesh.edges: + + if edgestyleSelect(e, mesh): + e.sel = 1 + else: + e.sel = 0 + def _doProjection(self, mesh, projector): """Calculate the Projection for the object. """ @@ -991,6 +1141,20 @@ class Renderer: # # --------------------------------------------------------------------- +# A dictionary to collect all the different edge styles and their edge +# selection criteria +edgeSelectionStyles = { + 'normal': MeshUtils().isVisibleEdge, + 'silhouette': MeshUtils().isSilhouetteEdge + } + +# A dictionary to collect the supported output formats +outputWriters = { + 'SVG': SVGVectorWriter, + } + + +# A wrapper function for the vectorizing process def vectorize(filename): """The vectorizing process is as follows: @@ -1001,30 +1165,23 @@ def vectorize(filename): editmode = Window.EditMode() if editmode: Window.EditMode(0) - writer = SVGVectorWriter(filename) + writer = outputWriters[OUTPUT_FORMAT](filename) renderer = Renderer() renderer.doRendering(writer, RENDER_ANIMATION) if editmode: Window.EditMode(1) -def vectorize_gui(filename): - """Draw the gui. - - I would like to keep that simple, really. - """ - Blender.Window.FileSelector (vectorize, 'Save SVG', filename) - Blender.Redraw() - # Here the main if __name__ == "__main__": - import os - outputfile = os.path.splitext(Blender.Get('filename'))[0]+".svg" + basename = Blender.sys.basename(Blender.Get('filename')) + outputfile = Blender.sys.splitext(basename)[0]+".svg" - # with this trick we can run the script in batch mode - try: - vectorize_gui(outputfile) - except: + if Blender.mode == 'background': vectorize(outputfile) + else: + label = "Save %s" % OUTPUT_FORMAT + Blender.Window.FileSelector(vectorize, label, outputfile) + Blender.Redraw()