X-Git-Url: https://git.ao2.it/vrm.git/blobdiff_plain/93ab13c89413991d1b26e747c5e953b61bf530ed..dafb24918e83227315727f0e3255823fcd7c5304:/vrm.py diff --git a/vrm.py b/vrm.py old mode 100644 new mode 100755 index 380a65b..871131e --- a/vrm.py +++ b/vrm.py @@ -1,33 +1,326 @@ #!BPY - """ Name: 'VRM' -Blender: 228 +Blender: 241 Group: 'Export' -Tooltip: 'Vector Rendering Method Export Script' +Tooltip: 'Vector Rendering Method Export Script 0.3' """ +# --------------------------------------------------------------------- +# Copyright (c) 2006 Antonio Ospite +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +# +# --------------------------------------------------------------------- +# +# NOTE: I do not know who is the original author of 'vrm'. +# The present code is almost entirely rewritten from scratch, +# but if I have to give credits to anyone, please let me know, +# so I can update the copyright. +# +# --------------------------------------------------------------------- +# +# Additional credits: +# Thanks to Emilio Aguirre for S2flender from which I took inspirations :) +# Thanks to Anthony C. D'Agostino for the backface.py script +# +# --------------------------------------------------------------------- import Blender -from Blender import Scene, Object, Lamp, Camera +from Blender import Scene, Object, NMesh, Lamp, Camera +from Blender.Mathutils import * from math import * -from Blender.Window import * - -def init(): - print "Init\n" - renderDir = scena.getRenderdir() +# --------------------------------------------------------------------- +# +## Projections classes +# +# --------------------------------------------------------------------- + +class Projector: + """Calculate the projection of an object given the camera. + + A projector is useful to so some per-object transformation to obtain the + projection of an object given the camera. + + The main method is #doProjection# see the method description for the + parameter list. + """ + + def __init__(self, cameraObj, obMesh, canvasSize): + """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]) + near = camera.clipStart + far = camera.clipEnd + + fovy = atan(0.5/aspect/(camera.lens/32)) + fovy = fovy * 360/pi + + # What projection do we want? + if camera.type: + m2 = self._calcOrthoMatrix(fovy, aspect, near, far, 17) #camera.scale) + else: + m2 = self._calcPerspectiveMatrix(fovy, aspect, near, far) + + m1 = Matrix() + mP = Matrix() + + # View transformation + cam = cameraObj.getInverseMatrix() + cam.transpose() + + m1 = obMesh.getMatrix() + m1.transpose() + + mP = cam * m1 + mP = m2 * mP + + self.projectionMatrix = mP + + ## + # Public methods + # + + def doProjection(self, v): + """Project the point on the view plane. + + Given a vertex calculate the projection using the current projection + matrix. + """ + + # 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] = int(p[0]*mW)+mW + p[1] = int(p[1]*mH)+mH + else: + p[0] = int((p[0]/p[3])*mW)+mW + p[1] = int((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] + + return p + + ## + # Private methods + # + + def _calcPerspectiveMatrix(self, fovy, aspect, near, far): + """Return a perspective projection matrix.""" + + top = near * tan(fovy * pi / 360.0) + bottom = -top + left = bottom*aspect + right= top*aspect + x = (2.0 * near) / (right-left) + y = (2.0 * near) / (top-bottom) + a = (right+left) / (right-left) + b = (top+bottom) / (top - bottom) + c = - ((far+near) / (far-near)) + d = - ((2*far*near)/(far-near)) + + m = Matrix( + [x, 0.0, a, 0.0], + [0.0, y, b, 0.0], + [0.0, 0.0, c, d], + [0.0, 0.0, -1.0, 0.0]) + + return m + + def _calcOrthoMatrix(self, fovy, aspect , near, far, scale): + """Return an orthogonal projection matrix.""" + + top = near * tan(fovy * pi / 360.0) * (scale * 10) + bottom = -top + left = bottom * aspect + right= top * aspect + rl = right-left + tb = top-bottom + fn = near-far + tx = -((right+left)/rl) + ty = -((top+bottom)/tb) + tz = ((far+near)/fn) + + m = Matrix( + [2.0/rl, 0.0, 0.0, tx], + [0.0, 2.0/tb, 0.0, ty], + [0.0, 0.0, 2.0/fn, tz], + [0.0, 0.0, 0.0, 1.0]) + + return m + + +# --------------------------------------------------------------------- +# +## Mesh representation class +# +# --------------------------------------------------------------------- + +# TODO: a class to represent the needed properties of a 2D vector image +# Just use a NMesh structure? + + +# --------------------------------------------------------------------- +# +## Vector Drawing Classes +# +# --------------------------------------------------------------------- + +## A generic Writer + +class VectorWriter: + """ + A class for printing output in a vectorial format. + + Given a 2D representation of the 3D scene the class is responsible to + write it is a vector format. + + Every subclasses of VectorWriter must have at last the following public + methods: + - printCanvas(mesh) --- where mesh is as specified before. + """ + + def __init__(self, fileName, canvasSize): + """Open the file named #fileName# and set the canvas size.""" + + self.file = open(fileName, "w") + print "Outputting to: ", fileName + + self.canvasSize = canvasSize + + + ## + # Public Methods + # + + def printCanvas(mesh): + return + + ## + # Private Methods + # + + def _printHeader(): + return + + def _printFooter(): + return + + +## SVG Writer + +class SVGVectorWriter(VectorWriter): + """A concrete class for writing SVG output. + + The class does not support animations, yet. + Sorry. + """ -# distance from camera Z' -def Distance(PX,PY,PZ): + def __init__(self, file, canvasSize): + """Simply call the parent Contructor.""" + VectorWriter.__init__(self, file, canvasSize) + + + ## + # Public Methods + # - dist = sqrt(PX*PX+PY*PY+PZ*PZ) - return dist + def printCanvas(self, scene): + """Convert the scene representation to SVG.""" + + self._printHeader() + + for obj in scene: + self.file.write("\n") + + for face in obj.faces: + self._printPolygon(face) -def Dodaj(x,y,z): + self.file.write("\n") + + self._printFooter() + + ## + # Private Methods + # - print "" + def _printHeader(self): + """Print SVG header.""" + + self.file.write("\n") + self.file.write("\n\n" % + self.canvasSize) + + def _printFooter(self): + """Print the SVG footer.""" + + self.file.write("\n\n") + self.file.close() + + def _printPolygon(self, face): + """Print our primitive, finally. + + There is no color Handling for now, *FIX!* + """ + + stroke_width=1 + + self.file.write("\n") + + +# --------------------------------------------------------------------- +# +## Rendering Classes +# +# --------------------------------------------------------------------- def RotatePoint(PX,PY,PZ,AngleX,AngleY,AngleZ): @@ -50,195 +343,228 @@ def RotatePoint(PX,PY,PZ,AngleX,AngleY,AngleZ): NewPoint.append(NewZ) return NewPoint -def flatern(vertx, verty, vertz): - - cam = Camera.get() # Get the cameras in scene - Lens = cam[0].getLens() # The First Blender camera lens - - camTyp = cam[0].getType() - - msize = scena.getWinSize() - xres = msize[0] # X res for output - yres = msize[1] # Y res for output - ratio = xres/yres - - screenxy=[0,0] - x=-vertx - y=verty - z=vertz - - fov = atan(ratio * 16.0 / Lens) # Get fov stuff - dist = xres/2*tan(fov) # Calculate dist from pinhole camera to image plane -#---------------------------- -# calculate x'=dist*x/z & y'=dist*x/z -#---------------------------- - screenxy[0]=int(xres/2+4*x*dist/z) - screenxy[1]=int(yres/2+4*y*dist/z) - return screenxy - -def writesvg(ob): - - for i in range(0, ob[0]+1): - print ob[i], "\n" - print "WriteSVG\n" - -######## -# Main # -######## - -scena = Scene.GetCurrent() -init() - -tacka = [0,0,0] -lice = [3,tacka,tacka,tacka,tacka] - -msize = scena.getWinSize() +class Renderer: + """Render a scene viewed from a given camera. + + This class is responsible of the rendering process, hence transormation + and projection of the ojects in the scene are invoked by the renderer. -file=open("d:\proba.svg","w") + The user can optionally provide a specific camera for the rendering, see + the #doRendering# method for more informations. + """ -file.write("\n") -#file.write("\n") + 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. + """ + self.canvasSize = (0.0, 0.0) -Objects = Blender.Object.Get() -NUMobjects = len(Objects) -startFrm = scena.startFrame() -endFrm = scena.endFrame() -camera = scena.getCurrentCamera() # Get the current camera + ## + # Public Methods + # -for f in range(startFrm, endFrm+1): - #scena.currentFrame(f) - Blender.Set('curframe', f) + def getCanvasSize(self): + """Return the current canvas size read from Blender rendering context""" + return self.canvasSize + + def doRendering(self, scene, cameraObj=None): + """Control the rendering process. + + Here we control the entire rendering process invoking the operation + needed to transforma project the 3D scene in two dimensions. - DrawProgressBar (f/(endFrm+1-startFrm),"Rendering ..." + str(scena.currentFrame())) + Parameters: + scene --- the Blender Scene to render + cameraObj --- the camera object to use for the viewing processing + """ - print "Frame: ", f, "\n" - if startFrm <> endFrm: file.write("\n") - for o in range(NUMobjects): + if cameraObj == None: + cameraObj = scene.getCurrentCamera() + + context = scene.getRenderingContext() + self.canvasSize = (context.imageSizeX(), context.imageSizeY()) + + Objects = scene.getChildren() + + # A structure to store the transformed scene + newscene = [] + + 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) + + # Let's store the transformed data + transformed_mesh = NMesh.New(obj.name) + + # Store the materials + materials = obj.getData().getMaterials() + + meshfaces = obj.getData().faces + + for face in meshfaces: + + # if the face is visible flatten it on the "picture plane" + if self._isFaceVisible(face, obj, cameraObj): + + # Store transformed face + transformed_face = [] + + for vert in face: + + p = proj.doProjection(vert.co) + + transformed_vert = NMesh.Vert(p[0], p[1], p[2]) + transformed_face.append(transformed_vert) + + newface = NMesh.Face(transformed_face) + + # Per-face color calculation + # code taken mostly from the original vrm script + # TODO: understand the code and rewrite it clearly + ambient = -250 + fakelight = [10, 10, 15] + norm = face.normal + vektori = (norm[0]*fakelight[0]+norm[1]*fakelight[1]+norm[2]*fakelight[2]) + vduzine = fabs(sqrt(pow(norm[0],2)+pow(norm[1],2)+pow(norm[2],2))*sqrt(pow(fakelight[0],2)+pow(fakelight[1],2)+pow(fakelight[2],2))) + intensity = floor(ambient + 200*acos(vektori/vduzine))/200 + if intensity < 0: + intensity = 0 + + if materials: + newface.col = materials[face.mat].getRGBCol() + else: + newface.col = [0.5, 0.5, 0.5] + + newface.col = [ (c>0) and (c-intensity) for c in newface.col] + + transformed_mesh.addFace(newface) + + # at the end of the loop on obj + + #transformed_object = NMesh.PutRaw(transformed_mesh) + newscene.append(transformed_mesh) + + # reverse the order (TODO: See how is the object order in NMesh) + #newscene.reverse() + + return newscene - if Objects[o].getType() == "Mesh": - obj = Objects[o] # Get the first selected object - objname = obj.name # The object name + ## + # Private Methods + # + def _isFaceVisible(self, face, obj, cameraObj): + """Determine if the face is visible from the current camera. - OBJmesh = obj.getData() # Get the mesh data for the object - numfaces=len(OBJmesh.faces) # The number of faces in the object - numEachVert=len(OBJmesh.faces[0]) # The number of verts in each face + The following code is taken basicly from the original vrm script. + """ - #------------ - # Get the Material Colors - #------------ -# MATinfo = OBJmesh.getMaterials() -# -# if len(MATinfo) > 0: -# RGB=MATinfo[0].rgbCol -# R=int(RGB[0]*255) -# G=int(RGB[1]*255) -# B=int(RGB[2]*255) -# color=`R`+"."+`G`+"."+`B` -# print color -# else: -# color="100.100.100" + camera = cameraObj - objekat = [] + numvert = len(face) - objekat.append(0) + # backface culling - for face in range(numfaces): - numvert = len(OBJmesh.faces[face]) - objekat.append(numvert) - objekat[0] += 1 + # 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) -# backface cutting a = [] - a.append(OBJmesh.faces[face][0][0]) - a.append(OBJmesh.faces[face][0][1]) - a.append(OBJmesh.faces[face][0][2]) + 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(OBJmesh.faces[face][1][0]) - b.append(OBJmesh.faces[face][1][1]) - b.append(OBJmesh.faces[face][1][2]) + 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(OBJmesh.faces[face][numvert-1][0]) - c.append(OBJmesh.faces[face][numvert-1][1]) - c.append(OBJmesh.faces[face][numvert-1][2]) + 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 = Vector([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(norm, Vector(a)) + + return (d<0) + + def _doClipping(face): + return + + +# --------------------------------------------------------------------- +# +## Main Program +# +# --------------------------------------------------------------------- + + +# hackish sorting of faces according to the max z value of a vertex +def zSorting(scene): + for o in scene: + o.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))) + o.faces.reverse() + +from Blender import sys +def vectorize(filename): + + print "Filename: %s" % filename + print + filename = filename.replace('/', sys.sep) + print filename + print + + scene = Scene.GetCurrent() + renderer = Renderer() + + flatScene = renderer.doRendering(scene) + canvasSize = renderer.getCanvasSize() + + zSorting(flatScene) + + writer = SVGVectorWriter(filename, canvasSize) + writer.printCanvas(flatScene) + +try: + Blender.Window.FileSelector (vectorize, 'Save SVG', "proba.svg") +except: + vectorize("proba.svg") - if d < 0: - file.write("\n") - if startFrm <> endFrm: - file.write("\n") - file.write("\n") - file.write("\n") - -#flatern() -#writesvg(objekat) -file.write("") -file.close() -DrawProgressBar (1.0,"Finished.") -print "Finished\n"