X-Git-Url: https://git.ao2.it/vrm.git/blobdiff_plain/b68056f960f3135bfa0d7e6327d06bf412b420cf..f3c77e9118aad35bfc7180996315c56b88b20706:/vrm.py diff --git a/vrm.py b/vrm.py index 00c8ed4..c694b77 100755 --- a/vrm.py +++ b/vrm.py @@ -34,12 +34,12 @@ Tooltip: 'Vector Rendering Method Export Script 0.3' # # Additional credits: # Thanks to Emilio Aguirre for S2flender from which I took inspirations :) -# Thanks to Anthony C. D'Agostino for the backface.py script +# Thanks to Anthony C. D'Agostino for the original backface.py script # # --------------------------------------------------------------------- import Blender -from Blender import Scene, Object, NMesh, Lamp, Camera +from Blender import Scene, Object, Mesh, NMesh, Lamp, Camera from Blender.Mathutils import * from math import * @@ -60,18 +60,16 @@ class Projector: parameter list. """ - def __init__(self, cameraObj, obMesh, canvasSize): + def __init__(self, cameraObj, canvasRatio): """Calculate the projection matrix. The projection matrix depends, in this case, on the camera settings, and also on object transformation matrix. """ - self.size = canvasSize - camera = cameraObj.getData() - aspect = float(canvasSize[0])/float(canvasSize[1]) + aspect = float(canvasRatio[0])/float(canvasRatio[1]) near = camera.clipStart far = camera.clipEnd @@ -88,11 +86,15 @@ class Projector: # View transformation cam = Matrix(cameraObj.getInverseMatrix()) cam.transpose() - - m1 = Matrix(obMesh.getMatrix()) - m1.transpose() - mP = cam * m1 + # FIXME: remove the commented part, we used to pass object in local + # coordinates, but this is not very clean, we should apply modelview + # tranformations _before_ (at some other level). + #m1 = Matrix(obMesh.getMatrix()) + #m1.transpose() + + #mP = cam * m1 + mP = cam mP = m2 * mP self.projectionMatrix = mP @@ -109,23 +111,12 @@ class Projector: """ # Note that we need the vertex expressed using homogeneous coordinates - p = self.projectionMatrix * Vector([v[0], v[1], v[2], 1.0]) - - mW = self.size[0]/2 - mH = self.size[1]/2 - - if p[3]<=0: - p[0] = round(p[0]*mW)+mW - p[1] = round(p[1]*mH)+mH - else: - p[0] = round((p[0]/p[3])*mW)+mW - p[1] = round((p[1]/p[3])*mH)+mH - - # For now we want (0,0) in the top-left corner of the canvas - # Mirror and translate along y - p[1] *= -1 - p[1] += self.size[1] - + p = self.projectionMatrix * Vector(v).resize4D() + + if p[3]>0: + p[0] = p[0]/p[3] + p[1] = p[1]/p[3] + return p ## @@ -179,7 +170,7 @@ class Projector: # --------------------------------------------------------------------- # -## Mesh representation class +## Object representation class # # --------------------------------------------------------------------- @@ -207,13 +198,15 @@ class VectorWriter: - printCanvas(mesh) --- where mesh is as specified before. """ - def __init__(self, fileName, canvasSize): + def __init__(self, fileName): """Open the file named #fileName# and set the canvas size.""" self.file = open(fileName, "w") print "Outputting to: ", fileName - self.canvasSize = canvasSize + + context = Scene.GetCurrent().getRenderingContext() + self.canvasSize = ( context.imageSizeX(), context.imageSizeY() ) ## @@ -243,30 +236,45 @@ class SVGVectorWriter(VectorWriter): Sorry. """ - def __init__(self, file, canvasSize): + def __init__(self, file): """Simply call the parent Contructor.""" - VectorWriter.__init__(self, file, canvasSize) + VectorWriter.__init__(self, file) ## # Public Methods # - - def printCanvas(self, scene): - """Convert the scene representation to SVG.""" + def open(self): self._printHeader() + + def close(self): + self._printFooter() + + + def printCanvas(self, scene, doPrintPolygons=True, doPrintEdges=False, showHiddenEdges=False): + """Convert the scene representation to SVG.""" + Objects = scene.getChildren() for obj in Objects: + + if(obj.getType() != 'Mesh'): + continue + # + self.file.write("\n") + - for face in obj.getData().faces: - self._printPolygon(face) + if doPrintPolygons: + for face in obj.getData().faces: + self._printPolygon(face) + if doPrintEdges: + self._printEdges(obj.getData(), showHiddenEdges) + self.file.write("\n") - self._printFooter() ## # Private Methods @@ -276,7 +284,9 @@ class SVGVectorWriter(VectorWriter): """Print SVG header.""" self.file.write("\n") - self.file.write("\n") + self.file.write("\n\n" % self.canvasSize) @@ -287,10 +297,45 @@ class SVGVectorWriter(VectorWriter): self.file.write("\n\n") self.file.close() + def _printEdges(self, mesh, showHiddenEdges=False): + """Print the wireframe using mesh edges... is this the correct way? + """ + + stroke_width=0.5 + stroke_col = [0, 0, 0] + + self.file.write("\n") + + for e in mesh.edges: + + hidden_stroke_style = "" + + # And edge is selected if both vertives are selected + if e.v1.sel == 0 or e.v2.sel == 0: + if showHiddenEdges == False: + continue + else: + hidden_stroke_style = ";\n stroke-dasharray:3, 3" + + p1 = self._calcCanvasCoord(e.v1) + p2 = self._calcCanvasCoord(e.v2) + + self.file.write("\n") + + self.file.write("\n") + + + def _printPolygon(self, face): """Print our primitive, finally. """ - + wireframe = False stroke_width=0.5 @@ -298,14 +343,18 @@ class SVGVectorWriter(VectorWriter): self.file.write("\n") + def _calcCanvasCoord(self, v): + + pt = Vector([0, 0, 0]) + + mW = self.canvasSize[0]/2 + mH = self.canvasSize[1]/2 + + # rescale to canvas size + pt[0] = round(v[0]*mW)+mW + pt[1] = round(v[1]*mH)+mH + + # For now we want (0,0) in the top-left corner of the canvas + # Mirror and translate along y + pt[1] *= -1 + pt[1] += self.canvasSize[1] + + return pt + # --------------------------------------------------------------------- # @@ -324,31 +391,10 @@ class SVGVectorWriter(VectorWriter): # # --------------------------------------------------------------------- -def RotatePoint(PX,PY,PZ,AngleX,AngleY,AngleZ): - - NewPoint = [] - # Rotate X - NewY = (PY * cos(AngleX))-(PZ * sin(AngleX)) - NewZ = (PZ * cos(AngleX))+(PY * sin(AngleX)) - # Rotate Y - PZ = NewZ - PY = NewY - NewZ = (PZ * cos(AngleY))-(PX * sin(AngleY)) - NewX = (PX * cos(AngleY))+(PZ * sin(AngleY)) - PX = NewX - PZ = NewZ - # Rotate Z - NewX = (PX * cos(AngleZ))-(PY * sin(AngleZ)) - NewY = (PY * cos(AngleZ))+(PX * sin(AngleZ)) - NewPoint.append(NewX) - NewPoint.append(NewY) - NewPoint.append(NewZ) - return NewPoint - class Renderer: """Render a scene viewed from a given camera. - This class is responsible of the rendering process, hence transormation + This class is responsible of the rendering process, hence transformation and projection of the ojects in the scene are invoked by the renderer. The user can optionally provide a specific camera for the rendering, see @@ -356,57 +402,133 @@ class Renderer: """ def __init__(self): - """Set the canvas size to a defaulr value. - - The only instance attribute here is the canvas size, which can be - queryed to the renderer by other entities. + """Make the rendering process only for the current scene by default. """ - self.canvasSize = (0.0, 0.0) + + # Render the current Scene set as a READ-ONLY property + self._SCENE = Scene.GetCurrent() + + # Use the aspect ratio of the scene rendering context + context = self._SCENE.getRenderingContext() + self.canvasRatio = (context.aspectRatioX(), context.aspectRatioY()) + + # Render from the currently active camera + self.camera = self._SCENE.getCurrentCamera() ## # Public Methods # - def getCanvasSize(self): - """Return the current canvas size read from Blender rendering context""" - return self.canvasSize + def doRendering(self, outputWriter, animation=0): + """Render picture or animation and write it out. - def doRendering(self, scene, cameraObj=None): - """Control the rendering process. + The parameters are: + - a Vector writer object than will be used to output the result. + - a flag to tell if we want to render an animation or the only + current frame. + """ - Here we control the entire rendering process invoking the operation - needed to transforma project the 3D scene in two dimensions. + context = self._SCENE.getRenderingContext() + currentFrame = context.currentFrame() - Parameters: - scene --- the Blender Scene to render - cameraObj --- the camera object to use for the viewing processing - """ + # Handle the animation case + if animation == 0: + startFrame = currentFrame + endFrame = startFrame + else: + startFrame = context.startFrame() + endFrame = context.endFrame() + + # Do the rendering process frame by frame + print "Start Rendering!" + for f in range(startFrame, endFrame+1): + context.currentFrame(f) + renderedScene = self.doRenderScene(self._SCENE) + outputWriter.printCanvas(renderedScene, + doPrintPolygons=False, doPrintEdges=True, showHiddenEdges=True) + + # clear the rendered scene + self._SCENE.makeCurrent() + Scene.unlink(renderedScene) + del renderedScene + + print "Done!" + context.currentFrame(currentFrame) - if cameraObj == None: - cameraObj = scene.getCurrentCamera() + + + def doRenderScene(self, inputScene): + """Control the rendering process. - context = scene.getRenderingContext() - self.canvasSize = (context.imageSizeX(), context.imageSizeY()) + Here we control the entire rendering process invoking the operation + needed to transform and project the 3D scene in two dimensions. + """ - Objects = scene.getChildren() + # Use some temporary workspace, a full copy of the scene + workScene = inputScene.copy(2) + + # Get a projector for this scene. + # NOTE: the projector wants object in world coordinates, + # so we should apply modelview transformations _before_ + # projection transformations + proj = Projector(self.camera, self.canvasRatio) + + # global processing of the scene + self._doDepthSorting(workScene) - # A structure to store the transformed scene - newscene = Scene.New("flat"+scene.name) + # Per object activities + Objects = workScene.getChildren() for obj in Objects: - if (obj.getType() != "Mesh"): + if (obj.getType() != 'Mesh'): print "Type:", obj.getType(), "\tSorry, only mesh Object supported!" continue + # + + self._doModelViewTransformations(obj) + + self._doBackFaceCulling(obj) + + self._doColorAndLighting(obj) + + # 'style' can be a function that determine + # if an edge should be showed? + self._doEdgesStyle(obj, style=None) + + self._doProjection(obj, proj) + + return workScene + + def oldRenderScene(scene): + + # Per object activities + Objects = workScene.getChildren() + + for obj in Objects: + + if (obj.getType() != 'Mesh'): + print "Type:", obj.getType(), "\tSorry, only mesh Object supported!" + continue + # Get a projector for this object - proj = Projector(cameraObj, obj, self.canvasSize) + proj = Projector(self.camera, obj, self.canvasSize) # Let's store the transformed data transformed_mesh = NMesh.New("flat"+obj.name) transformed_mesh.hasVertexColours(1) + # process Edges + self._doProcessEdges(obj) + + for v in obj.getData().verts: + transformed_mesh.verts.append(v) + transformed_mesh.edges = self._processEdges(obj.getData().edges) + #print transformed_mesh.edges + + # Store the materials materials = obj.getData().getMaterials() @@ -415,7 +537,7 @@ class Renderer: for face in meshfaces: # if the face is visible flatten it on the "picture plane" - if self._isFaceVisible_old(face, obj, cameraObj): + if self._isFaceVisible(face, obj, cameraObj): # Store transformed face newface = NMesh.Face() @@ -468,99 +590,184 @@ class Renderer: newscene.link(transformed_obj) - return newscene + return workScene ## # Private Methods # - def _isFaceVisible_old(self, face, obj, cameraObj): - """Determine if the face is visible from the current camera. + # Faces methods - The following code is taken basicly from the original vrm script. + def _isFaceVisible(self, face, obj, camObj): + """Determine if a face of an object is visible from a given camera. + + The normals need to be transformed, but note that we should apply only the + rotation part of the tranformation matrix, since the normals are + normalized and they can be intended as starting from the origin. + + The view vector is calculated from the camera location and one of the + vertices of the face (expressed in World coordinates, after applying + modelview transformations). + + After those transformations we determine if a face is visible by computing + the angle between the face normal and the view vector, this angle + corresponds somehow to the dot product between the two. If the product + results <= 0 then the angle between the two vectors is less that 90 + degrees and then the face is visible. + + There is no need to normalize those vectors since we are only interested in + the sign of the cross product and not in the product value. """ - camera = cameraObj - - numvert = len(face) - - # backface culling - - # translate and rotate according to the object matrix - # and then translate according to the camera position - #m = obj.getMatrix() - #m.transpose() - - #a = m*Vector(face[0]) - Vector(cameraObj.loc) - #b = m*Vector(face[1]) - Vector(cameraObj.loc) - #c = m*Vector(face[numvert-1]) - Vector(cameraObj.loc) - - a = [] - a.append(face[0][0]) - a.append(face[0][1]) - a.append(face[0][2]) - a = RotatePoint(a[0], a[1], a[2], obj.RotX, obj.RotY, obj.RotZ) - a[0] += obj.LocX - camera.LocX - a[1] += obj.LocY - camera.LocY - a[2] += obj.LocZ - camera.LocZ - b = [] - b.append(face[1][0]) - b.append(face[1][1]) - b.append(face[1][2]) - b = RotatePoint(b[0], b[1], b[2], obj.RotX, obj.RotY, obj.RotZ) - b[0] += obj.LocX - camera.LocX - b[1] += obj.LocY - camera.LocY - b[2] += obj.LocZ - camera.LocZ - c = [] - c.append(face[numvert-1][0]) - c.append(face[numvert-1][1]) - c.append(face[numvert-1][2]) - c = RotatePoint(c[0], c[1], c[2], obj.RotX, obj.RotY, obj.RotZ) - c[0] += obj.LocX - camera.LocX - c[1] += obj.LocY - camera.LocY - c[2] += obj.LocZ - camera.LocZ - - norm = [0, 0, 0] - norm[0] = (b[1] - a[1])*(c[2] - a[2]) - (c[1] - a[1])*(b[2] - a[2]) - norm[1] = -((b[0] - a[0])*(c[2] - a[2]) - (c[0] - a[0])*(b[2] - a[2])) - norm[2] = (b[0] - a[0])*(c[1] - a[1]) - (c[0] - a[0])*(b[1] - a[1]) - - d = norm[0]*a[0] + norm[1]*a[1] + norm[2]*a[2] - #d = DotVecs(Vector(norm), Vector(a)) - - return (d<0) - - def _isFaceVisible(self, face, obj, cameraObj): - """Determine if the face is visible from the current camera. + # The transformation matrix of the object + mObj = Matrix(obj.getMatrix()) + mObj.transpose() + + # The normal after applying the current object rotation + #normal = mObj.rotationPart() * Vector(face.no) + normal = Vector(face.no) + + # View vector in orthographics projections can be considered simply s the + # camera position + #view_vect = Vector(camObj.loc) + + # View vector as in perspective projections + # it is the dofference between the camera position and + # one point of the face, we choose the first point, + # but maybe a better choice may be the farthest point from the camera. + point = Vector(face[0].co) + #point = mObj * point.resize4D() + #point.resize3D() + view_vect = Vector(camObj.loc) - point + - The following code is taken basicly from the original vrm script. - """ + # if d <= 0 the face is visible from the camera + d = view_vect * normal + + if d <= 0: + return False + else: + return True - camera = cameraObj - numvert = len(face) + # Scene methods - # backface culling + def _doClipping(): + return - # translate and rotate according to the object matrix - # and then translate according to the camera position - m = obj.getMatrix() - m.transpose() + def _doDepthSorting(self, scene): + + cameraObj = self.camera + Objects = scene.getChildren() + + Objects.sort(lambda obj1, obj2: + cmp(Vector(Vector(cameraObj.loc) - Vector(obj1.loc)).length, + Vector(Vector(cameraObj.loc) - Vector(obj2.loc)).length + ) + ) - a = m*Vector(face[0]) - Vector(cameraObj.loc) - b = m*Vector(face[1]) - Vector(cameraObj.loc) - c = m*Vector(face[numvert-1]) - Vector(cameraObj.loc) + # hackish sorting of faces according to the max z value of a vertex + for o in Objects: - norm = m*Vector(face.no) + if (o.getType() != 'Mesh'): + continue + # - d = DotVecs(norm, a) + mesh = o.data + mesh.faces.sort( + lambda f1, f2: + # Sort faces according to the min z coordinate in a face + #cmp(min([v[2] for v in f1]), min([v[2] for v in f2]))) + + # Sort faces according to the max z coordinate in a face + cmp(max([v[2] for v in f1]), max([v[2] for v in f2]))) + + # Sort faces according to the avg z coordinate in a face + #cmp(sum([v[2] for v in f1])/len(f1), sum([v[2] for v in f2])/len(f2))) + mesh.faces.reverse() + mesh.update() + + # update the scene + # FIXME: check if it is correct + scene.update() + #for o in scene.getChildren(): + # scene.unlink(o) + #for o in Objects: + # scene.link(o) + + # Per object methods + + def _doModelViewTransformations(self, object): + if(object.getType() != 'Mesh'): + return + + matMV = object.matrix + mesh = object.data + mesh.transform(matMV, True) + mesh.update() - return (d<0) - def _doClipping(face): + def _doBackFaceCulling(self, object): + if(object.getType() != 'Mesh'): + return + + print "doing Backface Culling" + mesh = object.data + + # Select all vertices, so edges without faces can be displayed + for v in mesh.verts: + v.sel = 1 + + Mesh.Mode(Mesh.SelectModes['FACE']) + # Loop on faces + for f in mesh.faces: + f.sel = 0 + if self._isFaceVisible(f, object, self.camera): + f.sel = 1 + + 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 + + mesh.update() + + + + #Mesh.Mode(Mesh.SelectModes['VERTEX']) + + def _doColorAndLighting(self, object): + return + + def _doEdgesStyle(self, object, style): + """Process Mesh Edges. (For now copy the edge data, in next version it + can be a place where recognize silouhettes and/or contours). + + input: an edge list + return: a processed edge list + """ return + def _doProjection(self, object, projector): + + if(object.getType() != 'Mesh'): + return + + mesh = object.data + for v in mesh.verts: + p = projector.doProjection(v.co) + v[0] = p[0] + v[1] = p[1] + v[2] = p[2] + mesh.update() + + # --------------------------------------------------------------------- # @@ -570,62 +777,41 @@ class Renderer: # FIXME: really hackish code, just to test if the other parts work -def depthSorting(scene): - - cameraObj = Scene.GetCurrent().getCurrentCamera() - Objects = scene.getChildren() - - Objects.sort(lambda obj1, obj2: - cmp(Vector(Vector(cameraObj.loc) - Vector(obj1.loc)).length, - Vector(Vector(cameraObj.loc) - Vector(obj2.loc)).length - ) - ) - - # hackish sorting of faces according to the max z value of a vertex - for o in Objects: - - mesh = o.data - mesh.faces.sort( - lambda f1, f2: - # Sort faces according to the min z coordinate in a face - #cmp(min([v[2] for v in f1]), min([v[2] for v in f2]))) - - # Sort faces according to the max z coordinate in a face - cmp(max([v[2] for v in f1]), max([v[2] for v in f2]))) - - # Sort faces according to the avg z coordinate in a face - #cmp(sum([v[2] for v in f1])/len(f1), sum([v[2] for v in f2])/len(f2))) - mesh.faces.reverse() - mesh.update() - - # update the scene - for o in scene.getChildren(): - scene.unlink(o) - for o in Objects: - scene.link(o) def vectorize(filename): - - print "Filename: %s" % filename + """The vectorizing process is as follows: + + - Open the writer + - Render the scene + - Close the writer + + If you want to render an animation the second pass should be + repeated for any frame, and the frame number should be passed to the + renderer. + """ + writer = SVGVectorWriter(filename) + + writer.open() - scene = Scene.GetCurrent() renderer = Renderer() + renderer.doRendering(writer) - flatScene = renderer.doRendering(scene) - canvasSize = renderer.getCanvasSize() - - depthSorting(flatScene) + writer.close() - writer = SVGVectorWriter(filename, canvasSize) - writer.printCanvas(flatScene) - - Blender.Scene.unlink(flatScene) - del flatScene # Here the main if __name__ == "__main__": + # with this trick we can run the script in batch mode try: Blender.Window.FileSelector (vectorize, 'Save SVG', "proba.svg") + Blender.Redraw() except: + from Blender import Window + editmode = Window.EditMode() + if editmode: Window.EditMode(0) + vectorize("proba.svg") + if editmode: Window.EditMode(1) + +