From: Antonio Ospite Date: Sat, 13 May 2006 11:21:49 +0000 (+0200) Subject: Some stabilization work X-Git-Tag: vrm-0.3~32 X-Git-Url: https://git.ao2.it/vrm.git/commitdiff_plain/f3c77e9118aad35bfc7180996315c56b88b20706 Some stabilization work * Handle the canvas aspect ratio in the output writer not in the render * Remove the RotatePoint routine, as it is not used * Add proper rendering for animation * Use a better visibility routine * Use a better depth-sort routine * Factorize model-view transormation and back-face culling routines Signed-off-by: Antonio Ospite --- diff --git a/vrm.py b/vrm.py index d85b085..c694b77 100755 --- a/vrm.py +++ b/vrm.py @@ -39,7 +39,7 @@ Tooltip: 'Vector Rendering Method Export Script 0.3' # --------------------------------------------------------------------- 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 ## @@ -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,32 +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) - self._printWireframe(obj.getData()) + if doPrintEdges: + self._printEdges(obj.getData(), showHiddenEdges) self.file.write("\n") - self._printFooter() ## # Private Methods @@ -291,25 +297,35 @@ class SVGVectorWriter(VectorWriter): self.file.write("\n\n") self.file.close() - def _printWireframe(self, mesh): + def _printEdges(self, mesh, showHiddenEdges=False): """Print the wireframe using mesh edges... is this the correct way? """ - print mesh.edges - print - print mesh.verts - 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") @@ -319,7 +335,7 @@ class SVGVectorWriter(VectorWriter): def _printPolygon(self, face): """Print our primitive, finally. """ - + wireframe = False stroke_width=0.5 @@ -327,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 + # --------------------------------------------------------------------- # @@ -353,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 @@ -385,62 +402,131 @@ 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): + 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. + """ + + context = self._SCENE.getRenderingContext() + currentFrame = context.currentFrame() + + # 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) + + + + def doRenderScene(self, inputScene): """Control the rendering process. Here we control the entire rendering process invoking the operation - needed to transforma project the 3D scene in two dimensions. - - Parameters: - scene --- the Blender Scene to render - cameraObj --- the camera object to use for the viewing processing + needed to transform and project the 3D scene in two dimensions. """ + + # Use some temporary workspace, a full copy of the scene + workScene = inputScene.copy(2) - if cameraObj == None: - cameraObj = scene.getCurrentCamera() + # 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) - context = scene.getRenderingContext() - self.canvasSize = (context.imageSizeX(), context.imageSizeY()) + # Per object activities + Objects = workScene.getChildren() - Objects = scene.getChildren() + for obj in Objects: + + 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): - # 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 - + # 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 + #print transformed_mesh.edges # Store the materials @@ -451,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() @@ -504,110 +590,162 @@ 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. - 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 view vector is calculated from the camera location and one of the + vertices of the face (expressed in World coordinates, after applying + modelview transformations). - The following code is taken basicly from the original vrm script. + 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 + # The transformation matrix of the object + mObj = Matrix(obj.getMatrix()) + mObj.transpose() - numvert = len(face) + # The normal after applying the current object rotation + #normal = mObj.rotationPart() * Vector(face.no) + normal = Vector(face.no) - # backface culling + # View vector in orthographics projections can be considered simply s the + # camera position + #view_vect = Vector(camObj.loc) - # translate and rotate according to the object matrix - # and then translate according to the camera position - m = obj.getMatrix() - m.transpose() + # 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 - 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) - - norm = m*Vector(face.no) - d = DotVecs(norm, a) + # if d <= 0 the face is visible from the camera + d = view_vect * normal + + if d <= 0: + return False + else: + return True - return (d<0) + # Scene methods def _doClipping(): return + 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 + ) + ) + + # hackish sorting of faces according to the max z value of a vertex + for o in Objects: + + if (o.getType() != 'Mesh'): + continue + # + + 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 _doVisibleSurfaceDetermination(object): - return + def _doModelViewTransformations(self, object): + if(object.getType() != 'Mesh'): + return + + matMV = object.matrix + mesh = object.data + mesh.transform(matMV, True) + mesh.update() + + + 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 - def _doColorizing(object): + mesh.update() + + + + #Mesh.Mode(Mesh.SelectModes['VERTEX']) + + def _doColorAndLighting(self, object): return - def _doStylizingEdges(self, object, style): + 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). @@ -616,6 +754,19 @@ class Renderer: """ 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() + # --------------------------------------------------------------------- @@ -626,39 +777,6 @@ 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): """The vectorizing process is as follows: @@ -671,28 +789,29 @@ def vectorize(filename): repeated for any frame, and the frame number should be passed to the renderer. """ - - print "Filename: %s" % filename + writer = SVGVectorWriter(filename) - scene = Scene.GetCurrent() - renderer = Renderer() + writer.open() - flatScene = renderer.doRendering(scene) - canvasSize = renderer.getCanvasSize() - - depthSorting(flatScene) + renderer = Renderer() + renderer.doRendering(writer) - writer = SVGVectorWriter(filename, canvasSize) - writer.printCanvas(flatScene) + writer.close() - 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) + +