diff options
Diffstat (limited to 'release/scripts/export_dxf.py')
| -rw-r--r-- | release/scripts/export_dxf.py | 3041 |
1 files changed, 0 insertions, 3041 deletions
diff --git a/release/scripts/export_dxf.py b/release/scripts/export_dxf.py deleted file mode 100644 index 17f2132fbe8..00000000000 --- a/release/scripts/export_dxf.py +++ /dev/null @@ -1,3041 +0,0 @@ -#!BPY - -""" - Name: 'Autodesk DXF (.dxf/dwg)' - Blender: 249 - Group: 'Export' - Tooltip: 'Export geometry to DXF/DWG-r12 (Drawing eXchange Format).' -""" - -__version__ = "1.35 - 2009.06.18" -__author__ = "Remigiusz Fiedler (AKA migius)" -__license__ = "GPL" -__url__ = "http://wiki.blender.org/index.php/Scripts/Manual/Export/autodesk_dxf" -__bpydoc__ ="""The script exports Blender geometry to DXF format r12 version. - -Version %s -Copyright %s -License %s - -extern dependances: dxfLibrary.py, dxfColorMap.py (optionaly: DConvertCon.exe) - -CONTRIBUTORS: -Remigiusz Fiedler (AKA migius) -Alexandros Sigalas (AKA alxarch) -Stani Michiels (AKA stani) - -See the homepage for documentation. -url: %s - -IDEAs: -- HPGL output, usefull for correct scaled printing of 2d drawings - -TODO: -- export dupligroups and dupliverts as blocks (as option) -- optimize POLYFACE routine: remove double-vertices -- fix support for X,Y-rotated curves(to POLYLINEs): fix blender negative-matrix.invert() -- support hierarchies: groups, instances, parented structures -- support n/f-gons as POLYFACEs with invisible edges -- mapping materials to DXF-styles -- ProgressBar -- export rotation of Camera to VIEW/VPORT -- export parented Cameras to VIEW/VPORT -- wip: write drawing extends for automatic view positioning in CAD -- wip: fix text-objects in persp-projection -- wip: translate current 3D-View to *ACTIVE-VPORT -- wip: fix support Include-Duplis, cause not conform with INSERT-method - -History -v1.35 - 2009.06.18 by migius -- export multiple-instances of Curve-Objects as BLOCK/INSERTs -- added export Cameras (ortho and persp) to VPORTs, incl. clipping -- added export Cameras (ortho and persp) to VIEWs, incl. clipping -- export multiple-instances of Mesh-Objects as BLOCK/INSERTs -- on start prints dxfLibrary version -v1.34 - 2009.06.08 by migius -- export Lamps and Cameras as POINTs -- export passepartout for perspective projection -- added option for export objects only from visible layers -- optimized POLYFACE output: remove loose vertices in back-faces-mode -- cleaning code -- fix nasty bug in getExtrusion() -- support text-objects, also in ortho/persp-projection -- support XYmirrored 2d-curves to 2dPOLYLINEs -- support thickness and elevation for curve-objects -- fix extrusion 210-code (3d orientation vector) -- fix POLYFACE export, synchronized also dxfLibrary.py -- changed to the new 2.49 method Vector.cross() -- output style manager (first try) -v1.33 - 2009.05.25 by migius -- bugfix flipping normals in mirrored mesh-objects -- added UI-Button for future Shadow Generator -- support curve objects in projection-2d mode -- UI stuff: camera selector/manager -v1.32 - 2009.05.22 by migius -- debug mode for curve-objects: output redirect to Blender -- wip support 210-code(extrusion) calculation -- default settings for 2D and 3D export -v1.31 - 2009.05.18 by migius -- globals translated to GUI_A/B dictionary -- optimizing back-faces removal for "hidden-lines" mode -- presets for global location and scale (architecture) -- UI layout: scrollbars, pan with MMB/WHEEL, dynamic width -- new GUI with Draw.Register() from DXF-importer.py -v1.30 - 2008.12.14 by migius -- started work on GUI with Draw.Register() -v1.29 - 2009.04.11 by stani -- added DWG support, Stani Michiels idea for binding an extern DXF-DWG-converter -v1.28 - 2009.02.05 by Alexandros Sigalas (alxarch) -- added option to apply modifiers on exported meshes -- added option to also export duplicates (from dupliverts etc) -v1.28 - 2008.10.22 by migius -- workaround for PVert-bug on ubuntu (reported by Yorik) -- add support for FGons - ignore invisible_tagged edges -- add support for camera: ortho and perspective -v1.27 - 2008.10.07 by migius -- exclude Stani's DXF-Library to extern module -v1.26 - 2008.10.05 by migius -- add "hidden mode" substitut: back-faces removal -- add support for mesh ->POLYFACE -- optimized code for "Flat" procedure -v1.25 - 2008.09.28 by migius -- modif FACE class for r12 -- add mesh-polygon -> Bezier-curve converter (Yorik's code) -- add support for curves ->POLYLINEs -- add "3d-View to Flat" - geometry projection to XY-plane -v1.24 - 2008.09.27 by migius -- add start UI with preferences -- modif POLYLINE class for r12 -- changing output format from r9 to r12(AC1009) -v1.23 - 2008.09.26 by migius -- add finish message-box -v1.22 - 2008.09.26 by migius -- add support for curves ->LINEs -- add support for mesh-edges ->LINEs -v1.21 - 2008.06.04 by migius -- initial adaptation for Blender -v1.1 (20/6/2005) by Stani Michiels www.stani.be/python/sdxf -- Python library to generate dxf drawings -______________________________________________________________ -""" % (__author__,__version__,__license__,__url__) - -# -------------------------------------------------------------------------- -# Script copyright (C) 2008 Remigiusz Fiedler (AKA migius) -# -------------------------------------------------------------------------- -# ***** BEGIN GPL LICENSE BLOCK ***** -# -# 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -# -# ***** END GPL LICENCE BLOCK ***** - - -import Blender -from Blender import Mathutils, Window, Scene, Draw, Camera, BezTriple -from Blender import Registry, Object, Mesh, Curve -import os -import subprocess - -try: - import dxfLibrary as DXF - #reload(DXF) - #reload(dxfLibrary) - #from dxfLibrary import * -except: - DXF=None - print "DXF-Exporter: error! found no dxfLibrary.py module in Blender script folder" - Draw.PupMenu("Error%t|found no dxfLibrary.py module in script folder") - - -import math -from math import atan, atan2, log10, sin, cos - -#pi = math.pi -#pi = 3.14159265359 -r2d = 180.0 / math.pi -d2r = math.pi / 180.0 -#note: d2r * angle == math.radians(angle) -#note: r2d * angle == math.degrees(angle) - - -#DEBUG = True #activates debug mode - - -#----globals------------------------------------------ -ONLYSELECTED = 1 # 0/1 = False/True -ONLYVISIBLE = 1 # ignore objects on invisible layers -POLYLINES = 1 # prefer POLYLINEs not LINEs -POLYFACES = 1 # prefer POLYFACEs not 3DFACEs -PROJECTION = 0 # output geometry will be projected to XYplane with Z=0.0 -HIDDEN_LINES = 0 #filter out hidden geometry -SHADOWS = 0 # sun/shadows simulation -CAMERA = 1 # selected camera index -PERSPECTIVE = 0 # projection (camera) type: perspective, opposite to orthographic -CAMERAVIEW = 0 # use camera for projection, opposite is 3d-view -INSTANCES = 1 # Export instances of Mesh/Curve as BLOCK/INSERTs on/off -APPLY_MODIFIERS = 1 -INCLUDE_DUPLIS = 0 -OUTPUT_DWG = 0 #optional save to DWG with extern converter - -G_SCALE = 1.0 #(0.0001-1000) global scaling factor for output dxf data -G_ORIGIN = [0.0,0.0,0.0] #global translation-vector (x,y,z) in Blender units -ELEVATION = 0.0 #standard elevation = coordinate Z value in Blender units - -BYBLOCK = 0 #DXF-attribute: assign property to BLOCK defaults -BYLAYER = None #256 #DXF-attribute: assign property to LAYER defaults -PREFIX = 'BF_' #used as prefix for DXF names -LAYERNAME_DEF = '' #default layer name -LAYERCOLOR_DEF = 7 #default layer color index -LAYERLTYPE_DEF = 0 #'CONTINUOUS' - default layer lineType -ENTITYLAYER_DEF = LAYERNAME_DEF #default entity color index -ENTITYCOLOR_DEF = BYLAYER #default entity color index -ENTITYLTYPE_DEF = BYLAYER #default entity lineType - -E_M = 0 -LAB = "scroll MMB/WHEEL . wip .. todo" #"*) parts under construction" -M_OBJ = 0 - -FILENAME_MAX = 180 #max length of path+file_name string (FILE_MAXDIR + FILE_MAXFILE) -NAMELENGTH_MAX = 80 #max_obnamelength in DXF, (limited to 256? ) -INIFILE_DEFAULT_NAME = 'exportDXF' -INIFILE_EXTENSION = '.ini' -INIFILE_HEADER = '#ExportDXF.py ver.1.0 config data' -INFFILE_HEADER = '#ExportDXF.py ver.1.0 analyze of DXF-data' - -BLOCKREGISTRY = {} # registry and map for BLOCKs -SCENE = None -WORLDX = Mathutils.Vector((1,0,0)) -WORLDY = Mathutils.Vector((0,1,0)) -WORLDZ = Mathutils.Vector((0,0,1)) - -AUTO = BezTriple.HandleTypes.AUTO -FREE = BezTriple.HandleTypes.FREE -VECT = BezTriple.HandleTypes.VECT -ALIGN = BezTriple.HandleTypes.ALIGN - - -#-------- DWG support ------------------------------------------ -extCONV_OK = True -extCONV = 'DConvertCon.exe' -extCONV_PATH = os.path.join(Blender.Get('scriptsdir'),extCONV) -if not os.path.isfile(extCONV_PATH): - extCONV_OK = False - extCONV_TEXT = 'DWG-Exporter: Abort, nothing done!|\ -Copy first %s into Blender script directory.|\ -More details in online Help.' %extCONV -else: - if not os.sys.platform.startswith('win'): - # check if Wine installed: - if subprocess.Popen(('which', 'winepath'), stdout=subprocess.PIPE).stdout.read().strip(): - extCONV_PATH = 'wine %s'%extCONV_PATH - else: - extCONV_OK = False - extCONV_TEXT = 'DWG-Exporter: Abort, nothing done!|\ -The external DWG-converter (%s) needs Wine installed on your system.|\ -More details in online Help.' %extCONV -#print 'extCONV_PATH = ', extCONV_PATH - - -#---------------------------------------------- -def updateMenuCAMERA(): - global CAMERAS - global MenuCAMERA - global MenuLIGHT - - scn = Scene.GetCurrent() - objs = scn.getChildren() - currcam = scn.getCurrentCamera() - if currcam: currcam = currcam.getName() - maincams = [] - MenuCAMERA = "Select Camera%t" - for cam in objs: - if cam.getType() == 'Camera': - if cam.getName()[0:4] != "Temp": - maincams.append(cam.getName()) - maincams.sort() - maincams.reverse() - CAMERAS = maincams - for i, cam in enumerate(CAMERAS): - if cam==currcam: - MenuCAMERA += "|* " + cam - else: MenuCAMERA += "| " + cam - MenuCAMERA += "|current 3d-View" - MenuLIGHT = "Select Sun%t| *todo" - - -#---------------------------------------------- -def updateCAMERA(): - global CAMERA, GUI_A - #CAMERA = 1 - scn = Scene.GetCurrent() - currcam = scn.getCurrentCamera() - if currcam: currcam = currcam.getName() - if currcam in CAMERAS: - CAMERA = CAMERAS.index(currcam)+1 - GUI_A['camera_selected'].val = CAMERA - -#---------------------------------------------- -def gotoCAMERA(): - cam = Object.Get(CAMERAS[CAMERA-1]) - #print 'deb: CAMERA, cam',CAMERA, cam - if cam.getType() != 'Camera': - sure = Draw.PupMenu("Info: %t| It is not a Camera Object.") - else: - scn = Scene.getCurrent() - scn.setCurrentCamera(cam) - Window.CameraView(0) - Window.Redraw() - updateMenuCAMERA() - - -#------- Duplicates support ---------------------------------------------- -def dupTest(object): - """ - Checks objects for duplicates enabled (any type) - object: Blender Object. - Returns: Boolean - True if object has any kind of duplicates enabled. - """ - if (object.enableDupFrames or \ - object.enableDupGroup or \ - object.enableDupVerts): - return True - else: - return False - -def getObjectsAndDuplis(oblist,MATRICES=False,HACK=False): - """ - Return a list of real objects and duplicates and optionally their matrices - oblist: List of Blender Objects - MATRICES: Boolean - Check to also get the objects matrices, default=False - HACK: Boolean - See note, default=False - Returns: List of objects or - List of tuples of the form:(ob,matrix) if MATRICES is set to True - NOTE: There is an ugly hack here that excludes all objects whose name - starts with "dpl_" to exclude objects that are parented to a duplicating - object, User must name objects properly if hack is used. - """ - - result = [] - for ob in oblist: - if INCLUDE_DUPLIS and dupTest(ob): - dup_obs=ob.DupObjects - if len(dup_obs): - for dup_ob, dup_mx in dup_obs: - if MATRICES: - result.append((dup_ob,dup_mx)) - else: - result.append(dup_ob) - else: - if HACK: - if ob.getName()[0:4] != "dpl_": - if MATRICES: - mx = ob.mat - result.append((ob,mx)) - else: - result.append(ob) - else: - if MATRICES: - mx = ob.mat - result.append((ob,mx)) - else: - result.append(ob) - return result - -#----------------------------------------------------- -def hidden_status(faces, mx, mx_n): - # sort out back-faces = with normals pointed away from camera - #print 'HIDDEN_LINES: caution! not full implemented yet' - front_faces = [] - front_edges = [] - for f in faces: - #print 'deb: face=', f #--------- - #print 'deb: dir(face)=', dir(f) #--------- - # get its normal-vector in localCS - vec_normal = f.no.copy() - #print 'deb: vec_normal=', vec_normal #------------------ - # must be transfered to camera/view-CS - vec_normal *= mx_n - #vec_normal *= mb.rotationPart() - #print 'deb:2vec_normal=', vec_normal #------------------ - #vec_normal *= mw0.rotationPart() - #print 'deb:3vec_normal=', vec_normal, '\n' #------------------ - - - frontFace = False - if not PERSPECTIVE: #for ortho mode ---------- - # normal must point the Z direction-hemisphere - if vec_normal[2] > 0.00001: - frontFace = True - else: - v = f.verts[0] - vert = Mathutils.Vector(v.co) * mx - if Mathutils.DotVecs(vert, vec_normal) < 0.00001: - frontFace = True - - if frontFace: - front_faces.append(f.index) - for key in f.edge_keys: - #this test can be done faster with set() - if key not in front_edges: - front_edges.append(key) - - #print 'deb: amount of visible faces=', len(front_faces) #--------- - #print 'deb: visible faces=', front_faces #--------- - #print 'deb: amount of visible edges=', len(front_edges) #--------- - #print 'deb: visible edges=', front_edges #--------- - return front_faces, front_edges - - -#---- migration to 2.49------------------------------------------------- -if 'cross' in dir(Mathutils.Vector()): - #Draw.PupMenu('DXF exporter: Abort%t|This script version works for Blender up 2.49 only!') - def M_CrossVecs(v1,v2): - return v1.cross(v2) #for up2.49 - def M_DotVecs(v1,v2): - return v1.dot(v2) #for up2.49 -else: - def M_CrossVecs(v1,v2): - return Mathutils.CrossVecs(v1,v2) #for pre2.49 - def M_DotVecs(v1,v2): - return Mathutils.DotVecs(v1,v2) #for pre2.49 - - -#----------------------------------------------------- -def getExtrusion(matrix): - """calculates DXF-Extrusion = Arbitrary Xaxis and Zaxis vectors - - """ - AZaxis = matrix[2].copy().resize3D().normalize() # = ArbitraryZvector - Extrusion = [AZaxis[0],AZaxis[1],AZaxis[2]] - if AZaxis[2]==1.0: - Extrusion = None - AXaxis = matrix[0].copy().resize3D() # = ArbitraryXvector - else: - threshold = 1.0 / 64.0 - if abs(AZaxis[0]) < threshold and abs(AZaxis[1]) < threshold: - # AXaxis is the intersection WorldPlane and ExtrusionPlane - AXaxis = M_CrossVecs(WORLDY,AZaxis) - else: - AXaxis = M_CrossVecs(WORLDZ,AZaxis) - #print 'deb:\n' #------------- - #print 'deb:getExtrusion() Extrusion=', Extrusion #--------- - return Extrusion, AXaxis.normalize() - - -#----------------------------------------------------- -def getZRotation(AXaxis, rot_matrix_invert): - """calculates ZRotation = angle between ArbitraryXvector and obj.matrix.Xaxis - - """ - # this works: Xaxis is the obj.matrix-Xaxis vector - # but not correct for all orientations - #Xaxis = matrix[0].copy().resize3D() # = ArbitraryXvector - ##Xaxis.normalize() # = ArbitraryXvector - #ZRotation = - Mathutils.AngleBetweenVecs(Xaxis,AXaxis) #output in radians - - # this works for all orientations, maybe a bit faster - # transform AXaxis into OCS:Object-Coord-System - #rot_matrix = normalizeMat(matrix.rotationPart()) - #rot_matrix_invert = rot_matrix.invert() - vec = AXaxis * rot_matrix_invert - ##vec = AXaxis * matrix.copy().invert() - ##vec.normalize() # not needed for atan2() - #print '\ndeb:getExtrusion() vec=', vec #--------- - ZRotation = - atan2(vec[1],vec[0]) #output in radians - - #print 'deb:ZRotation() ZRotation=', ZRotation*r2d #--------- - return ZRotation - - -#------------------------------------------ -def normalizeMat(matrix): - mat12 = matrix.copy() - mat12 = [Mathutils.Vector(v).normalize() for v in mat12] - if len(mat12)>3: - matr12 = Mathutils.Matrix(mat12[0],mat12[1],mat12[2],mat12[3]) - else: - matr12 = Mathutils.Matrix(mat12[0],mat12[1],mat12[2]) - return matr12 - - -#----------------------------------------------------- -def projected_co(verts, matrix): - """ converts coordinates of points from OCS to WCS->ScreenCS - needs matrix: a projection matrix - needs verts: a list of vectors[x,y,z] - returns a list of [x,y,z] - """ - #print 'deb:projected_co() verts=', verts #--------- - temp_verts = [Mathutils.Vector(v)*matrix for v in verts] - #print 'deb:projected_co() temp_verts=', temp_verts #--------- - - if GUI_A['Z_force_on'].val: locZ = GUI_A['Z_elev'].val - else: locZ = 0.0 - - if PROJECTION: - if PERSPECTIVE: - clipStart = 10.0 - for v in temp_verts: - coef = - clipStart / v[2] - v[0] *= coef - v[1] *= coef - v[2] = locZ - for v in temp_verts: - v[2] = locZ - temp_verts = [v[:3] for v in temp_verts] - #print 'deb:projected_co() out_verts=', temp_verts #--------- - return temp_verts - - -#----------------------------------------------------- -def isLeftHand(matrix): - #Is the matrix a left-hand-system, or not? - ma = matrix.rotationPart() - crossXY = M_CrossVecs(ma[0], ma[1]) - check = M_DotVecs(ma[2], crossXY) - if check < 0.00001: return 1 - return 0 - - -#----------------------------------------------------- -def exportMesh(ob, mx, mx_n, me=None, **common): - """converts Mesh-Object to desired projection and representation(DXF-Entity type) - """ - global BLOCKREGISTRY - entities = [] - block = None - #print 'deb:exportMesh() given common=', common #--------- - if me==None: - me = ob.getData(mesh=1) - else: - me.getFromObject(ob) - # idea: me.transform(mx); get verts data; me.transform(mx_inv)= back to the origin state - # the .transform-method is fast, but bad, cause invasive: - # it manipulates original geometry and by retransformation lefts back rounding-errors - # we dont want to manipulate original data! - #temp_verts = me.verts[:] #doesn't work on ubuntu(Yorik), bug? - if me.verts: - #print 'deb:exportMesh() started' #--------- - - #print 'deb:exportMesh() ob.name=', ob.name #--------- - #print 'deb:exportMesh() me.name=', me.name #--------- - #print 'deb:exportMesh() me.users=', me.users #--------- - # check if there are more instances of this mesh (if used by other objects), then write to BLOCK/INSERT - if GUI_A['instances_on'].val and me.users>1 and not PROJECTION: - if me.name in BLOCKREGISTRY.keys(): - insert_name = BLOCKREGISTRY[me.name] - # write INSERT to entities - entities = exportInsert(ob, mx,insert_name, **common) - else: - # generate geom_output in ObjectCS - allpoints = [v.co for v in me.verts] - identity_matrix = Mathutils.Matrix().identity() - allpoints = projected_co(allpoints, identity_matrix) - #allpoints = toGlobalOrigin(allpoints) - faces=[] - edges=[] - for e in me.edges: edges.append(e.key) - faces = [[v.index for v in f.verts] for f in me.faces] - entities = writeMeshEntities(allpoints, edges, faces, **common) - if entities: # if not empty block - # write BLOCK definition and INSERT entity - # BLOCKREGISTRY = dictionary 'blender_name':'dxf_name'.append(me.name) - BLOCKREGISTRY[me.name]=validDXFr12name(('ME_'+ me.name)) - insert_name = BLOCKREGISTRY[me.name] - block = DXF.Block(insert_name,flag=0,base=(0,0,0),entities=entities) - # write INSERT as entity - entities = exportInsert(ob, mx, insert_name, **common) - - else: # no other instances, so go the standard way - allpoints = [v.co for v in me.verts] - allpoints = projected_co(allpoints, mx) - allpoints = toGlobalOrigin(allpoints) - faces=[] - edges=[] - if me.faces and PROJECTION and HIDDEN_LINES: - #if DEBUG: print 'deb:exportMesh HIDDEN_LINES mode' #--------- - faces, edges = hidden_status(me.faces, mx, mx_n) - faces = [[v.index for v in me.faces[f_nr].verts] for f_nr in faces] - else: - #if DEBUG: print 'deb:exportMesh STANDARD mode' #--------- - for e in me.edges: edges.append(e.key) - #faces = [f.index for f in me.faces] - faces = [[v.index for v in f.verts] for f in me.faces] - #faces = [[allpoints[v.index] for v in f.verts] for f in me.faces] - #print 'deb: allpoints=\n', allpoints #--------- - #print 'deb: edges=\n', edges #--------- - #print 'deb: faces=\n', faces #--------- - if isLeftHand(mx): # then change vertex-order in every face - for f in faces: - f.reverse() - #f = [f[-1]] + f[:-1] #TODO: might be needed - #print 'deb: faces=\n', faces #--------- - entities = writeMeshEntities(allpoints, edges, faces, **common) - - return entities, block - - -#------------------------------------------------- -def writeMeshEntities(allpoints, edges, faces, **common): - """help routine for exportMesh() - """ - entities = [] - - c = mesh_as_list[GUI_A['mesh_as'].val] - if 'POINTs'==c: # export Mesh as multiple POINTs - for p in allpoints: - dxfPOINT = DXF.Point(points=[p],**common) - entities.append(dxfPOINT) - elif 'LINEs'==c or (not faces): - if edges and allpoints: - if DEBUG: mesh_drawBlender(allpoints, edges, None) #deb: draw to blender scene - for e in edges: - points = [allpoints[e[0]], allpoints[e[1]]] - dxfLINE = DXF.Line(points, **common) - entities.append(dxfLINE) - elif faces: - if c in ('POLYFACE','POLYLINE'): - if allpoints: - #TODO: purge allpoints: left only vertices used by faces - if DEBUG: mesh_drawBlender(allpoints, None, faces) #deb: draw to scene - if not (PROJECTION and HIDDEN_LINES): - faces = [[v+1 for v in f] for f in faces] - else: - # for back-Faces-mode remove face-free verts - map=verts_state= [0]*len(allpoints) - for f in faces: - for v in f: - verts_state[v]=1 - if 0 in verts_state: # if dirty state - i,newverts=0,[] - for used_i,used in enumerate(verts_state): - if used: - newverts.append(allpoints[used_i]) - map[used_i]=i - i+=1 - allpoints = newverts - faces = [[map[v]+1 for v in f] for f in faces] - dxfPOLYFACE = DXF.PolyLine([allpoints, faces], flag=64, **common) - #print '\n deb: dxfPOLYFACE=',dxfPOLYFACE #------------- - entities.append(dxfPOLYFACE) - elif '3DFACEs'==c: - if DEBUG: mesh_drawBlender(allpoints, None, faces) #deb: draw to scene - for f in faces: - #print 'deb: face=', f #--------- - points = [allpoints[key] for key in f] - #points = [p.co[:3] for p in points] - #print 'deb: pointsXX=\n', points #--------- - dxfFACE = DXF.Face(points, **common) - entities.append(dxfFACE) - - return entities - - -#----------------------------------------------------- -def mesh_drawBlender(vertList, edgeList, faceList, name="dxfMesh", flatten=False, AT_CUR=True, link=True): - #print 'deb:mesh_drawBlender started XXXXXXXXXXXXXXXXXX' #--------- - ob = Object.New("Mesh",name) - me = Mesh.New(name) - #print 'deb: vertList=\n', vertList #--------- - #print 'deb: edgeList=\n', edgeList #--------- - #print 'deb: faceList=\n', faceList #--------- - me.verts.extend(vertList) - if edgeList: me.edges.extend(edgeList) - if faceList: me.faces.extend(faceList) - if flatten: - for v in me.verts: v.co.z = 0.0 - ob.link(me) - if link: - sce = Scene.getCurrent() - sce.objects.link(ob) - #me.triangleToQuad() - if AT_CUR: - cur_loc = Window.GetCursorPos() - ob.setLocation(cur_loc) - Blender.Redraw() - #return ob - -#----------------------------------------------------- -def curve_drawBlender(vertList, org_point=[0.0,0.0,0.0], closed=0, name="dxfCurve", flatten=False, AT_CUR=True, link=True): - #print 'deb:curve_drawBlender started XXXXXXXXXXXXXXXXXX' #--------- - ob = Object.New("Curve",name) - cu = Curve.New(name) - #print 'deb: vertList=\n', vertList #--------- - curve = cu.appendNurb(BezTriple.New(vertList[0])) - for p in vertList[1:]: - curve.append(BezTriple.New(p)) - for point in curve: - #point.handleTypes = [VECT, VECT] - point.handleTypes = [FREE, FREE] - point.radius = 1.0 - curve.flagU = closed # 0 sets the curve not cyclic=open - cu.setResolu(6) - cu.update() #important for handles calculation - if flatten: - for v in cu.verts: v.co.z = 0.0 - ob.link(cu) - if link: - sce = Scene.getCurrent() - sce.objects.link(ob) - #me.triangleToQuad() - if AT_CUR: - cur_loc = Window.GetCursorPos() - ob.setLocation(cur_loc) - elif org_point: - cur_loc=org_point - ob.setLocation(cur_loc) - Blender.Redraw() - #return ob - - -#----------------------------------------------------- -def toGlobalOrigin(points): - """relocates points to the new location - needs a list of points [x,y,z] - """ - if GUI_A['g_origin_on'].val: - for p in points: - p[0] += G_ORIGIN[0] - p[1] += G_ORIGIN[1] - p[2] += G_ORIGIN[2] - return points - - -#----------------------------------------------------- -def exportEmpty(ob, mx, mw, **common): - """converts Empty-Object to desired projection and representation(DXF-Entity type) - """ - p = Mathutils.Vector(ob.loc) - [p] = projected_co([p], mx) - [p] = toGlobalOrigin([p]) - - entities = [] - c = empty_as_list[GUI_A['empty_as'].val] - if c=="POINT": # export Empty as POINT - dxfPOINT = DXF.Point(points=[p],**common) - entities.append(dxfPOINT) - return entities - -#----------------------------------------------------- -def exportCamera(ob, mx, mw, **common): - """converts Camera-Object to desired projection and representation(DXF-Entity type) - """ - location = Mathutils.Vector(ob.loc) - [location] = projected_co([location], mx) - [location] = toGlobalOrigin([location]) - view_name=validDXFr12name(('CAM_'+ ob.name)) - - camera = Camera.Get(ob.getData(name_only=True)) - #print 'deb: camera=', dir(camera) #------------------ - if camera.type=='persp': - mode = 1+2+4+16 - # mode flags: 1=persp, 2=frontclip, 4=backclip,16=FrontZ - elif camera.type=='ortho': - mode = 0+2+4+16 - - leftBottom=(0.0,0.0) # default - rightTop=(1.0,1.0) # default - center=(0.0,0.0) # default - - direction = Mathutils.Vector(0.0,0.0,1.0) * mx.rotationPart() # in W-C-S - direction.normalize() - target=Mathutils.Vector(ob.loc) - direction # in W-C-S - #ratio=1.0 - width=height= camera.scale # for ortho-camera - lens = camera.lens # for persp-camera - frontClipping = -(camera.clipStart - 1.0) - backClipping = -(camera.clipEnd - 1.0) - - entities, vport, view = [], None, None - c = camera_as_list[GUI_A['camera_as'].val] - if c=="POINT": # export as POINT - dxfPOINT = DXF.Point(points=[location],**common) - entities.append(dxfPOINT) - elif c=="VIEW": # export as VIEW - view = DXF.View(name=view_name, - center=center, width=width, height=height, - frontClipping=frontClipping,backClipping=backClipping, - direction=direction,target=target,lens=lens,mode=mode - ) - elif c=="VPORT": # export as VPORT - vport = DXF.VPort(name=view_name, - center=center, ratio=1.0, height=height, - frontClipping=frontClipping,backClipping=backClipping, - direction=direction,target=target,lens=lens,mode=mode - ) - return entities, vport, view - -#----------------------------------------------------- -def exportLamp(ob, mx, mw, **common): - """converts Lamp-Object to desired projection and representation(DXF-Entity type) - """ - p = Mathutils.Vector(ob.loc) - [p] = projected_co([p], mx) - [p] = toGlobalOrigin([p]) - - entities = [] - c = lamp_as_list[GUI_A['lamp_as'].val] - if c=="POINT": # export as POINT - dxfPOINT = DXF.Point(points=[p],**common) - entities.append(dxfPOINT) - return entities - -#----------------------------------------------------- -def exportInsert(ob, mx, insert_name, **common): - """converts Object to DXF-INSERT in given orientation - """ - WCS_loc = ob.loc # WCS_loc is object location in WorldCoordSystem - sizeX = ob.SizeX - sizeY = ob.SizeY - sizeZ = ob.SizeZ - rotX = ob.RotX - rotY = ob.RotY - rotZ = ob.RotZ - #print 'deb: sizeX=%s, sizeY=%s' %(sizeX, sizeY) #--------- - - Thickness,Extrusion,ZRotation,Elevation = None,None,None,None - - AXaxis = mx[0].copy().resize3D() # = ArbitraryXvector - if not PROJECTION: - #Extrusion, ZRotation, Elevation = getExtrusion(mx) - Extrusion, AXaxis = getExtrusion(mx) - - entities = [] - - if 1: - if not PROJECTION: - ZRotation,Zrotmatrix,OCS_origin,ECS_origin = getTargetOrientation(mx,Extrusion,\ - AXaxis,WCS_loc,sizeX,sizeY,sizeZ,rotX,rotY,rotZ) - ZRotation *= r2d - point = ECS_origin - else: #TODO: fails correct location - point1 = Mathutils.Vector(ob.loc) - [point] = projected_co([point1], mx) - if PERSPECTIVE: - clipStart = 10.0 - coef = -clipStart / (point1*mx)[2] - #print 'deb: coef=', coef #-------------- - #TODO: ? sizeX *= coef - #sizeY *= coef - #sizeZ *= coef - - #print 'deb: point=', point #-------------- - [point] = toGlobalOrigin([point]) - - #if DEBUG: text_drawBlender(textstr,points,OCS_origin) #deb: draw to scene - common['extrusion']= Extrusion - #common['elevation']= Elevation - #print 'deb: common=', common #------------------ - if 0: #DEBUG - #linepoints = [[0,0,0], [AXaxis[0],AXaxis[1],AXaxis[2]]] - linepoints = [[0,0,0], point] - dxfLINE = DXF.Line(linepoints,**common) - entities.append(dxfLINE) - - xscale=sizeX - yscale=sizeY - zscale=sizeZ - cols=None - colspacing=None - rows=None - rowspacing=None - - dxfINSERT = DXF.Insert(insert_name,point=point,rotation=ZRotation,\ - xscale=xscale,yscale=yscale,zscale=zscale,\ - cols=cols,colspacing=colspacing,rows=rows,rowspacing=rowspacing,\ - **common) - entities.append(dxfINSERT) - - return entities - - -#----------------------------------------------------- -def exportText(ob, mx, mw, **common): - """converts Text-Object to desired projection and representation(DXF-Entity type) - """ - text3d = ob.getData() - textstr = text3d.getText() - WCS_loc = ob.loc # WCS_loc is object location in WorldCoordSystem - sizeX = ob.SizeX - sizeY = ob.SizeY - sizeZ = ob.SizeZ - rotX = ob.RotX - rotY = ob.RotY - rotZ = ob.RotZ - #print 'deb: sizeX=%s, sizeY=%s' %(sizeX, sizeY) #--------- - - Thickness,Extrusion,ZRotation,Elevation = None,None,None,None - - AXaxis = mx[0].copy().resize3D() # = ArbitraryXvector - if not PROJECTION: - #Extrusion, ZRotation, Elevation = getExtrusion(mx) - Extrusion, AXaxis = getExtrusion(mx) - - # no thickness/width for TEXTs converted into ScreenCS - if text3d.getExtrudeDepth(): - Thickness = text3d.getExtrudeDepth() * sizeZ - - #Horizontal text justification type, code 72, (optional, default = 0) - # integer codes (not bit-coded) - #0=left, 1=center, 2=right - #3=aligned, 4=middle, 5=fit - Alignment = None - alignment = text3d.getAlignment().value - if alignment in (1,2): Alignment = alignment - - textHeight = text3d.getSize() / 1.7 - textFlag = 0 - if sizeX < 0.0: textFlag |= 2 # set flag for horizontal mirrored - if sizeZ < 0.0: textFlag |= 4 # vertical mirrored - - entities = [] - c = text_as_list[GUI_A['text_as'].val] - - if c=="TEXT": # export text as TEXT - if not PROJECTION: - ZRotation,Zrotmatrix,OCS_origin,ECS_origin = getTargetOrientation(mx,Extrusion,\ - AXaxis,WCS_loc,sizeX,sizeY,sizeZ,rotX,rotY,rotZ) - ZRotation *= r2d - point = ECS_origin - else: #TODO: fails correct location - point1 = Mathutils.Vector(ob.loc) - [point] = projected_co([point1], mx) - if PERSPECTIVE: - clipStart = 10.0 - coef = -clipStart / (point1*mx)[2] - textHeight *= coef - #print 'deb: coef=', coef #-------------- - - #print 'deb: point=', point #-------------- - [point] = toGlobalOrigin([point]) - point2 = point - - #if DEBUG: text_drawBlender(textstr,points,OCS_origin) #deb: draw to scene - common['extrusion']= Extrusion - #common['elevation']= Elevation - common['thickness']= Thickness - #print 'deb: common=', common #------------------ - if 0: #DEBUG - #linepoints = [[0,0,0], [AXaxis[0],AXaxis[1],AXaxis[2]]] - linepoints = [[0,0,0], point] - dxfLINE = DXF.Line(linepoints,**common) - entities.append(dxfLINE) - - dxfTEXT = DXF.Text(text=textstr,point=point,alignment=point2,rotation=ZRotation,\ - flag=textFlag,height=textHeight,justifyhor=Alignment,**common) - entities.append(dxfTEXT) - if Thickness: - common['thickness']= -Thickness - dxfTEXT = DXF.Text(text=textstr,point=point,alignment=point2,rotation=ZRotation,\ - flag=textFlag,height=textHeight,justifyhor=Alignment,**common) - entities.append(dxfTEXT) - return entities - - -#------------------------------------------- -def euler2matrix(rx, ry, rz): - """creates full 3D rotation matrix (optimized) - needs rx, ry, rz angles in radians - """ - #print 'rx, ry, rz: ', rx, ry, rz - A, B = sin(rx), cos(rx) - C, D = sin(ry), cos(ry) - E, F = sin(rz), cos(rz) - AC, BC = A*C, B*C - return Mathutils.Matrix([D*F, D*E, -C], - [AC*F-B*E, AC*E+B*F, A*D], - [BC*F+A*E, BC*E-A*F, B*D]) - - -#----------------------------------------------------- -def getTargetOrientation(mx,Extrusion,AXaxis,WCS_loc,sizeX,sizeY,sizeZ,rotX,rotY,rotZ): - """given - """ - if 1: - rot_matrix = normalizeMat(mx.rotationPart()) - #TODO: workaround for blender negative-matrix.invert() - # partially done: works only for rotX,rotY==0.0 - if sizeX<0.0: rot_matrix[0] *= -1 - if sizeY<0.0: rot_matrix[1] *= -1 - #if sizeZ<0.0: rot_matrix[2] *= -1 - rot_matrix_invert = rot_matrix.invert() - else: #TODO: to check, why below rot_matrix_invert is not equal above one - rot_euler_matrix = euler2matrix(rotX,rotY,rotZ) - rot_matrix_invert = euler2matrix(-rotX,-rotY,-rotZ) - - # OCS_origin is Global_Origin in ObjectCoordSystem - OCS_origin = Mathutils.Vector(WCS_loc) * rot_matrix_invert - #print 'deb: OCS_origin=', OCS_origin #--------- - - ZRotation = rotZ - if Extrusion!=None: - ZRotation = getZRotation(AXaxis,rot_matrix_invert) - #Zrotmatrix = Mathutils.RotationMatrix(-ZRotation, 3, "Z") - rs, rc = sin(ZRotation), cos(ZRotation) - Zrotmatrix = Mathutils.Matrix([rc, rs,0.0],[-rs,rc,0.0],[0.0,0.0,1.0]) - #print 'deb: Zrotmatrix=\n', Zrotmatrix #-------------- - - # ECS_origin is Global_Origin in EntityCoordSystem - ECS_origin = OCS_origin * Zrotmatrix - #print 'deb: ECS_origin=', ECS_origin #--------- - #TODO: it doesnt work yet for negative scaled curve-objects! - return ZRotation,Zrotmatrix,OCS_origin,ECS_origin - - -#----------------------------------------------------- -def exportCurve(ob, mx, mw, **common): - """converts Curve-Object to desired projection and representation(DXF-Entity type) - """ - entities = [] - block = None - curve = ob.getData() - #print 'deb: curve=', dir(curve) #--------- - # TODO: should be: if curve.users>1 and not (PERSPECTIVE or (PROJECTION and HIDDEN_MODE): - if GUI_A['instances_on'].val and curve.users>1 and not PROJECTION: - if curve.name in BLOCKREGISTRY.keys(): - insert_name = BLOCKREGISTRY[curve.name] - # write INSERT to entities - entities = exportInsert(ob, mx,insert_name, **common) - else: - # generate geom_output in ObjectCS - imx = Mathutils.Matrix().identity() - WCS_loc = [0,0,0] # WCS_loc is object location in WorldCoordSystem - #print 'deb: WCS_loc=', WCS_loc #--------- - sizeX = sizeY = sizeZ = 1.0 - rotX = rotY = rotZ = 0.0 - Thickness,Extrusion,ZRotation,Elevation = None,None,None,None - ZRotation,Zrotmatrix,OCS_origin,ECS_origin = None,None,None,None - AXaxis = imx[0].copy().resize3D() # = ArbitraryXvector - OCS_origin = [0,0,0] - if not PROJECTION: - #Extrusion, ZRotation, Elevation = getExtrusion(mx) - Extrusion, AXaxis = getExtrusion(imx) - - # no thickness/width for POLYLINEs converted into Screen-C-S - #print 'deb: curve.ext1=', curve.ext1 #--------- - if curve.ext1: Thickness = curve.ext1 * sizeZ - if curve.ext2 and sizeX==sizeY: - Width = curve.ext2 * sizeX - if "POLYLINE"==curve_as_list[GUI_A['curve_as'].val]: # export as POLYLINE - ZRotation,Zrotmatrix,OCS_origin,ECS_origin = getTargetOrientation(imx,Extrusion,\ - AXaxis,WCS_loc,sizeX,sizeY,sizeZ,rotX,rotY,rotZ) - - entities = writeCurveEntities(curve, imx, - Thickness,Extrusion,ZRotation,Elevation,AXaxis,Zrotmatrix, - WCS_loc,OCS_origin,ECS_origin,sizeX,sizeY,sizeZ, - **common) - - if entities: # if not empty block - # write BLOCK definition and INSERT entity - # BLOCKREGISTRY = dictionary 'blender_name':'dxf_name'.append(me.name) - BLOCKREGISTRY[curve.name]=validDXFr12name(('CU_'+ curve.name)) - insert_name = BLOCKREGISTRY[curve.name] - block = DXF.Block(insert_name,flag=0,base=(0,0,0),entities=entities) - # write INSERT as entity - entities = exportInsert(ob, mx, insert_name, **common) - - else: # no other instances, so go the standard way - WCS_loc = ob.loc # WCS_loc is object location in WorldCoordSystem - #print 'deb: WCS_loc=', WCS_loc #--------- - sizeX = ob.SizeX - sizeY = ob.SizeY - sizeZ = ob.SizeZ - rotX = ob.RotX - rotY = ob.RotY - rotZ = ob.RotZ - #print 'deb: sizeX=%s, sizeY=%s' %(sizeX, sizeY) #--------- - - Thickness,Extrusion,ZRotation,Elevation = None,None,None,None - ZRotation,Zrotmatrix,OCS_origin,ECS_origin = None,None,None,None - AXaxis = mx[0].copy().resize3D() # = ArbitraryXvector - OCS_origin = [0,0,0] - if not PROJECTION: - #Extrusion, ZRotation, Elevation = getExtrusion(mx) - Extrusion, AXaxis = getExtrusion(mx) - - # no thickness/width for POLYLINEs converted into Screen-C-S - #print 'deb: curve.ext1=', curve.ext1 #--------- - if curve.ext1: Thickness = curve.ext1 * sizeZ - if curve.ext2 and sizeX==sizeY: - Width = curve.ext2 * sizeX - if "POLYLINE"==curve_as_list[GUI_A['curve_as'].val]: # export as POLYLINE - ZRotation,Zrotmatrix,OCS_origin,ECS_origin = getTargetOrientation(mx,Extrusion,\ - AXaxis,WCS_loc,sizeX,sizeY,sizeZ,rotX,rotY,rotZ) - entities = writeCurveEntities(curve, mx, - Thickness,Extrusion,ZRotation,Elevation,AXaxis,Zrotmatrix, - WCS_loc,OCS_origin,ECS_origin,sizeX,sizeY,sizeZ, - **common) - - return entities, block - - -#------------------------------------------------- -def writeCurveEntities(curve, mx, - Thickness,Extrusion,ZRotation,Elevation,AXaxis,Zrotmatrix, - WCS_loc,OCS_origin,ECS_origin,sizeX,sizeY,sizeZ, - **common): - """help routine for exportCurve() - """ - entities = [] - - if 1: - for cur in curve: - #print 'deb: START cur=', cur #-------------- - points = [] - if cur.isNurb(): - for point in cur: - #print 'deb:isNurb point=', point #--------- - vec = point[0:3] - #print 'deb: vec=', vec #--------- - pkt = Mathutils.Vector(vec) - #print 'deb: pkt=', pkt #--------- - points.append(pkt) - else: - for point in cur: - #print 'deb:isBezier point=', point.getTriple() #--------- - vec = point.getTriple()[1] - #print 'deb: vec=', vec #--------- - pkt = Mathutils.Vector(vec) - #print 'deb: pkt=', pkt #--------- - points.append(pkt) - - #print 'deb: points', points #-------------- - if len(points)>1: - c = curve_as_list[GUI_A['curve_as'].val] - - if c=="POLYLINE": # export Curve as POLYLINE - if not PROJECTION: - # recalculate points(2d=X,Y) into Entity-Coords-System - for p in points: # list of vectors - p[0] *= sizeX - p[1] *= sizeY - p2 = p * Zrotmatrix - p2[0] += ECS_origin[0] - p2[1] += ECS_origin[1] - p[0],p[1] = p2[0],p2[1] - else: - points = projected_co(points, mx) - #print 'deb: points', points #-------------- - - if cur.isCyclic(): closed = 1 - else: closed = 0 - points = toGlobalOrigin(points) - - if DEBUG: curve_drawBlender(points,OCS_origin,closed) #deb: draw to scene - - common['extrusion']= Extrusion - ##common['rotation']= ZRotation - ##common['elevation']= Elevation - common['thickness']= Thickness - #print 'deb: common=', common #------------------ - - if 0: #DEBUG - p=AXaxis[:3] - entities.append(DXF.Line([[0,0,0], p],**common)) - p=ECS_origin[:3] - entities.append(DXF.Line([[0,0,0], p],**common)) - common['color']= 5 - p=OCS_origin[:3] - entities.append(DXF.Line([[0,0,0], p],**common)) - #OCS_origin=[0,0,0] #only debug---------------- - dxfPLINE = DXF.PolyLine(points,OCS_origin,closed,**common) - entities.append(dxfPLINE) - - dxfPLINE = DXF.PolyLine(points,OCS_origin,closed,**common) - entities.append(dxfPLINE) - if Thickness: - common['thickness']= -Thickness - dxfPLINE = DXF.PolyLine(points,OCS_origin,closed,**common) - entities.append(dxfPLINE) - - elif c=="LINEs": # export Curve as multiple LINEs - points = projected_co(points, mx) - if cur.isCyclic(): points.append(points[0]) - #print 'deb: points', points #-------------- - points = toGlobalOrigin(points) - - if DEBUG: curve_drawBlender(points,WCS_loc,closed) #deb: draw to scene - common['extrusion']= Extrusion - common['elevation']= Elevation - common['thickness']= Thickness - #print 'deb: common=', common #------------------ - for i in range(len(points)-1): - linepoints = [points[i], points[i+1]] - dxfLINE = DXF.Line(linepoints,**common) - entities.append(dxfLINE) - if Thickness: - common['thickness']= -Thickness - for i in range(len(points)-1): - linepoints = [points[i], points[i+1]] - dxfLINE = DXF.Line(linepoints,**common) - entities.append(dxfLINE) - - elif c=="POINTs": # export Curve as multiple POINTs - points = projected_co(points, mx) - for p in points: - dxfPOINT = DXF.Point(points=[p],**common) - entities.append(dxfPOINT) - return entities - - -#----------------------------------------------------- -def getClipBox(camera): - """calculates Field-of-View-Clipping-Box of given Camera - returns clip_box: a list of vertices - returns matr: translation matrix - """ - sce = Scene.GetCurrent() - context = sce.getRenderingContext() - #print 'deb: context=\n', context #------------------ - sizeX = context.sizeX - sizeY = context.sizeY - ratioXY = sizeX/float(sizeY) - #print 'deb: size X,Y, ratio=', sizeX, sizeY, ratioXY #------------------ - - clip1_Z = - camera.clipStart - clip2_Z = - camera.clipEnd - #print 'deb: clip Start=', camera.clipStart #------------------ - #print 'deb: clip End=', camera.clipEnd #------------------ - - if camera.type=='ortho': - scale = camera.scale - #print 'deb: camscale=', scale #------------------ - clip1shiftX = clip2shiftX = camera.shiftX * scale - clip1shiftY = clip2shiftY = camera.shiftY * scale - clip1_X = scale * 0.5 - clip1_Y = scale * 0.5 - if ratioXY > 1.0: clip1_Y /= ratioXY - else: clip1_X *= ratioXY - clip2_X = clip1_X - clip2_Y = clip1_Y - - near = clip1_Z - far = clip2_Z - right, left = clip1_X, -clip1_X - top, bottom = clip1_Y, -clip1_Y - - scaleX = 2.0/float(right - left) - x3 = -float(right + left)/float(right - left) - scaleY = 2.0/float(top - bottom) - y3 = -float(top + bottom)/float(top - bottom) - scaleZ = 1.0/float(far - near) - z3 = -float(near)/float(far - near) - - matrix = Mathutils.Matrix( [scaleX, 0.0, 0.0, x3], - [0.0, scaleY, 0.0, y3], - [0.0, 0.0, scaleZ, z3], - [0.0, 0.0, 0.0, 1.0]) - - elif camera.type=='persp': - #viewpoint = [0.0, 0.0, 0.0] #camera's coordinate system, hehe - #lens = camera.lens - angle = camera.angle - #print 'deb: cam angle=', angle #------------------ - shiftX = camera.shiftX - shiftY = camera.shiftY - fov_coef = atan(angle * d2r) - fov_coef *= 1.3 #incl. passpartou - clip1_k = clip1_Z * fov_coef - clip2_k = clip2_Z * fov_coef - clip1shiftX = - camera.shiftX * clip1_k - clip2shiftX = - camera.shiftX * clip2_k - clip1shiftY = - camera.shiftY * clip1_k - clip2shiftY = - camera.shiftY * clip2_k - clip1_X = clip1_Y = clip1_k * 0.5 - clip2_X = clip2_Y = clip2_k * 0.5 - if ratioXY > 1.0: - clip1_Y /= ratioXY - clip2_Y /= ratioXY - else: - clip1_X *= ratioXY - clip2_X *= ratioXY - - near = clip1_Z - far = clip2_Z - right, left = clip1_X, -clip1_X - top, bottom = clip1_Y, -clip1_Y - #return Matrix( [scaleX, 0.0, x2, 0.0], - #[0.0, scaleY, y2, 0.0], - #[0.0, 0.0, scaleZ, wZ], - #[0.0, 0.0, -1.0, 0.0]) - matrix = Mathutils.Matrix( [(2.0 * near)/float(right - left), 0.0, float(right + left)/float(right - left), 0.0], - [0.0, (2.0 * near)/float(top - bottom), float(top + bottom)/float(top - bottom), 0.0], - [0.0, 0.0, -float(far + near)/float(far - near), -(2.0 * far * near)/float(far - near)], - [0.0, 0.0, -1.0, 0.0]) - - - clip_box = [ - -clip1_X + clip1shiftX, clip1_X + clip1shiftX, - -clip1_Y + clip1shiftY, clip1_Y + clip1shiftY, - -clip2_X + clip2shiftX, clip2_X + clip2shiftX, - -clip2_Y + clip2shiftY, clip2_Y + clip2shiftY, - clip1_Z, clip2_Z] - #print 'deb: clip_box=\n', clip_box #------------------ - #drawClipBox(clip_box) - return clip_box, matrix - - -#----------------------------------------------------- -def drawClipBox(clip_box): - """debug tool: draws Clipping-Box of a Camera View - """ - min_X1, max_X1, min_Y1, max_Y1,\ - min_X2, max_X2, min_Y2, max_Y2,\ - min_Z, max_Z = clip_box - verts = [] - verts.append([min_X1, min_Y1, min_Z]) - verts.append([max_X1, min_Y1, min_Z]) - verts.append([max_X1, max_Y1, min_Z]) - verts.append([min_X1, max_Y1, min_Z]) - verts.append([min_X2, min_Y2, max_Z]) - verts.append([max_X2, min_Y2, max_Z]) - verts.append([max_X2, max_Y2, max_Z]) - verts.append([min_X2, max_Y2, max_Z]) - faces = [[0,1,2,3],[4,5,6,7]] - newmesh = Mesh.New() - newmesh.verts.extend(verts) - newmesh.faces.extend(faces) - - plan = Object.New('Mesh','clip_box') - plan.link(newmesh) - sce = Scene.GetCurrent() - sce.objects.link(plan) - plan.setMatrix(sce.objects.camera.matrix) - - -#------------------------------------------------- -def getCommons(ob): - """set up common attributes for output style: - color=None - extrusion=None - layer='0', - lineType=None - lineTypeScale=None - lineWeight=None - thickness=None - parent=None - """ - - layers = ob.layers #gives a list e.g.[1,5,19] - if layers: ob_layer_nr = layers[0] - #print 'ob_layer_nr=', ob_layer_nr #-------------- - - materials = ob.getMaterials() - if materials: - ob_material = materials[0] - ob_mat_color = ob_material.rgbCol - else: ob_mat_color, ob_material = None, None - #print 'ob_mat_color, ob_material=', ob_mat_color, ob_material #-------------- - - data = ob.getData() - data_materials = ob.getMaterials() - if data_materials: - data_material = data_materials[0] - data_mat_color = data_material.rgbCol - else: data_mat_color, data_material = None, None - #print 'data_mat_color, data_material=', data_mat_color, data_material #-------------- - - entitylayer = ENTITYLAYER_DEF - c = entitylayer_from_list[GUI_A['entitylayer_from'].val] - #["default_LAYER","obj.name","obj.layer","obj.material","obj.data.name","obj.data.material","..vertexgroup","..group","..map_table"] - if c=="default_LAYER": - entitylayer = LAYERNAME_DEF - elif c=="obj.layer" and ob_layer_nr: - entitylayer = 'LAYER'+ str(ob_layer_nr) - elif c=="obj.material" and ob_material: - entitylayer = ob_material.name - elif c=="obj.name": - entitylayer = ob.name - elif c=="obj.data.material" and ob_material: - entitylayer = data_material.name - elif c=="obj.data.name": - entitylayer = data.name - entitylayer = validDXFr12name(PREFIX+entitylayer) - if entitylayer=="": entitylayer = "BF_0" - - entitycolor = ENTITYCOLOR_DEF - c = entitycolor_from_list[GUI_A['entitycolor_from'].val] - if c=="default_COLOR": - entitycolor = LAYERCOLOR_DEF - elif c=="BYLAYER": - entitycolor = BYLAYER - elif c=="BYBLOCK": - entitycolor = BYBLOCK - elif c=="obj.layer" and ob_layer_nr: - entitycolor = ob_layer_nr - elif c=="obj.color" and ob.color: - entitycolor = col2DXF(ob.color) - elif c=="obj.material" and ob_mat_color: - entitycolor = col2DXF(ob_mat_color) - elif c=="obj.data.material" and data_mat_color: - entitycolor = col2DXF(data_mat_color) - #if entitycolor!=None: layercolor = entitycolor - - entityltype = ENTITYLTYPE_DEF - c = entityltype_from_list[GUI_A['entityltype_from'].val] - if c=="default_LTYPE": - entityltype = LAYERLTYPE_DEF - elif c=="BYLAYER": - entityltype = BYLAYER - elif c=="BYBLOCK": - entityltype = BYBLOCK - elif c: - entityltype = c - - return entitylayer,entitycolor,entityltype - - -#----------------------------------------------------- -def do_export(export_list, filepath): - global PERSPECTIVE, CAMERAVIEW, BLOCKREGISTRY - Window.WaitCursor(1) - t = Blender.sys.time() - - # init Drawing --------------------- - d=DXF.Drawing() - # add Tables ----------------- - # initialized automatic: d.blocks.append(b) #section BLOCKS - # initialized automatic: d.styles.append(DXF.Style()) #table STYLE - - #table LTYPE --------------- - #d.linetypes.append(DXF.LineType(name='CONTINUOUS',description='--------',elements=[0.0])) - d.linetypes.append(DXF.LineType(name='DOT',description='. . . . . . .',elements=[0.25, 0.0, -0.25])) - d.linetypes.append(DXF.LineType(name='DASHED',description='__ __ __ __ __',elements=[0.8, 0.5, -0.3])) - d.linetypes.append(DXF.LineType(name='DASHDOT',description='__ . __ . __ .',elements=[1.0, 0.5, -0.25, 0.0, -0.25])) - d.linetypes.append(DXF.LineType(name='DIVIDE',description='____ . . ____ . . ',elements=[1.25, 0.5, -0.25, 0.0, -0.25, 0.0, -0.25])) - d.linetypes.append(DXF.LineType(name='BORDER',description='__ __ . __ __ . ',elements=[1.75, 0.5, -0.25, 0.5, -0.25, 0.0, -0.25])) - d.linetypes.append(DXF.LineType(name='HIDDEN',description='__ __ __ __ __',elements=[0.4, 0.25, -0.25])) - d.linetypes.append(DXF.LineType(name='CENTER',description='____ _ ____ _ __',elements=[2.0, 1.25, -0.25, 0.25, -0.25])) - - #d.vports.append(DXF.VPort('*ACTIVE')) - d.vports.append(DXF.VPort('*ACTIVE',center=(-5.0,1.0),height=10.0)) - #d.vports.append(DXF.VPort('*ACTIVE',leftBottom=(-100.0,-60.0),rightTop=(100.0,60.0))) - #d.views.append(DXF.View('Normal')) #table view - d.views.append(DXF.ViewByWindow('BF_TOPVIEW',leftBottom=(-100,-60),rightTop=(100,60))) #idem - - # add Entities -------------------- - BLOCKREGISTRY = {} # registry and map for BLOCKs - PERSPECTIVE = 0 - something_ready = 0 - selected_len = len(export_list) - sce = Scene.GetCurrent() - - mw = Mathutils.Matrix( [1.0, 0.0, 0.0, 0.0], - [0.0, 1.0, 0.0, 0.0], - [0.0, 0.0, 1.0, 0.0], - [0.0, 0.0, 0.0, 1.0]) - if PROJECTION: - if CAMERA<len(CAMERAS)+1: # the biggest number is the current 3d-view - act_camera = Object.Get(CAMERAS[CAMERA-1]) - #context = sce.getRenderingContext() - #print 'deb: context=\n', context #------------------ - #print 'deb: context=\n', dir(context) #------------------ - #act_camera = sce.objects.camera - #print 'deb: act_camera=', act_camera #------------------ - if act_camera: - CAMERAVIEW = 1 - mc0 = act_camera.matrix.copy() - #print 'deb: camera.Matrix=\n', mc0 #------------------ - camera = Camera.Get(act_camera.getData(name_only=True)) - #print 'deb: camera=', dir(camera) #------------------ - if camera.type=='persp': PERSPECTIVE = 1 - elif camera.type=='ortho': PERSPECTIVE = 0 - # mcp is matrix.camera.perspective - clip_box, mcp = getClipBox(camera) - if PERSPECTIVE: - # get border - # lens = camera.lens - min_X1, max_X1, min_Y1, max_Y1,\ - min_X2, max_X2, min_Y2, max_Y2,\ - min_Z, max_Z = clip_box - verts = [] - verts.append([min_X1, min_Y1, min_Z]) - verts.append([max_X1, min_Y1, min_Z]) - verts.append([max_X1, max_Y1, min_Z]) - verts.append([min_X1, max_Y1, min_Z]) - border=verts - mw = mc0.copy().invert() - - else: # get 3D-View instead of camera-view - #ViewVector = Mathutils.Vector(Window.GetViewVector()) - #print 'deb: ViewVector=\n', ViewVector #------------------ - #TODO: what is Window.GetViewOffset() for? - #print 'deb: Window.GetViewOffset():', Window.GetViewOffset() #--------- - #Window.SetViewOffset([0,0,0]) - mw0 = Window.GetViewMatrix() - #print 'deb: mwOrtho =\n', mw0 #--------- - mwp = Window.GetPerspMatrix() #TODO: how to get it working? - #print 'deb: mwPersp =\n', mwp #--------- - mw = mw0.copy() - - #print 'deb: ViewMatrix=\n', mw #------------------ - - if APPLY_MODIFIERS: tmp_me = Mesh.New('tmp') - else: tmp_me = None - - if GUI_A['paper_space_on'].val==1: espace=1 - else: espace=None - - layernames = [] - for ob,mx in export_list: - entities = [] - block = None - #mx = ob.matrix.copy() - #print 'deb: ob =', ob #--------- - #print 'deb: ob.type =', ob.type #--------- - #print 'deb: mx =\n', mx #--------- - #print 'deb: mw0 =\n', mw0 #--------- - #mx_n is trans-matrix for normal_vectors for front-side faces - mx_n = mx.rotationPart() * mw.rotationPart() - if G_SCALE!=1.0: mx *= G_SCALE - mx *= mw - - #mx_inv = mx.copy().invert() - #print 'deb: mx =\n', mx #--------- - #print 'deb: mx_inv=\n', mx_inv #--------- - - if ob.type in ('Mesh','Curve','Empty','Text','Camera','Lamp'): - elayer,ecolor,eltype = getCommons(ob) - #print 'deb: elayer,ecolor,eltype =', elayer,ecolor,eltype #-------------- - - #TODO: use ob.boundBox for drawing extends - - if elayer!=None: - if elayer not in layernames: - layernames.append(elayer) - if ecolor!=None: tempcolor = ecolor - else: tempcolor = LAYERCOLOR_DEF - d.layers.append(DXF.Layer(color=tempcolor, name=elayer)) - - if (ob.type == 'Mesh') and GUI_B['bmesh'].val: - entities, block = exportMesh(ob, mx, mx_n, tmp_me,\ - paperspace=espace, color=ecolor, layer=elayer, lineType=eltype) - elif (ob.type == 'Curve') and GUI_B['bcurve'].val: - entities, block = exportCurve(ob, mx, mw, \ - paperspace=espace, color=ecolor, layer=elayer, lineType=eltype) - elif (ob.type == 'Empty') and GUI_B['empty'].val: - entities = exportEmpty(ob, mx, mw, \ - paperspace=espace, color=ecolor, layer=elayer, lineType=eltype) - elif (ob.type == 'Text') and GUI_B['text'].val: - entities = exportText(ob, mx, mw, \ - paperspace=espace, color=ecolor, layer=elayer, lineType=eltype) - elif (ob.type == 'Camera') and GUI_B['camera'].val: - entities, vport, view = exportCamera(ob, mx, mw, \ - paperspace=espace, color=ecolor, layer=elayer, lineType=eltype) - if vport: d.vports.append(vport) - if view: d.views.append(view) - elif (ob.type == 'Lamp') and GUI_B['lamp'].val: - entities = exportLamp(ob, mx, mw, \ - paperspace=espace, color=ecolor, layer=elayer, lineType=eltype) - - if entities: - something_ready += 1 - for e in entities: - d.append(e) - - if block: - d.blocks.append(block) #add to BLOCK-section - - - if something_ready: - if PERSPECTIVE: # generate view border - passepartout - identity_matrix = Mathutils.Matrix().identity() - points = projected_co(border, identity_matrix) - closed = 1 - points = toGlobalOrigin(points) - c = curve_as_list[GUI_A['curve_as'].val] - if c=="LINEs": # export Curve as multiple LINEs - for i in range(len(points)-1): - linepoints = [points[i], points[i+1]] - dxfLINE = DXF.Line(linepoints,paperspace=espace,color=LAYERCOLOR_DEF) - entities.append(dxfLINE) - else: - dxfPLINE = DXF.PolyLine(points,points[0],closed,\ - paperspace=espace, color=LAYERCOLOR_DEF) - d.append(dxfPLINE) - - - if not GUI_A['outputDWG_on'].val: - print 'writing to %s' % filepath - try: - d.saveas(filepath) - Window.WaitCursor(0) - #print '%s objects exported to %s' %(something_ready,filepath) - print '%s/%s objects exported in %.2f seconds. -----DONE-----' %(something_ready,selected_len,(Blender.sys.time()-t)) - Draw.PupMenu('DXF Exporter: job finished!| %s/%s objects exported in %.2f sek.' %(something_ready,selected_len, (Blender.sys.time()-t))) - except IOError: - Window.WaitCursor(0) - Draw.PupMenu('DXF Exporter: Write Error: Permission denied:| %s' %filepath) - - else: - if not extCONV_OK: - Draw.PupMenu(extCONV_TEXT) - Window.WaitCursor(False) - else: - print 'temp. exporting to %s' % filepath - d.saveas(filepath) - #Draw.PupMenu('DXF Exporter: job finished') - #print 'exported to %s' % filepath - #print 'finished in %.2f seconds' % (Blender.sys.time()-t) - filedwg = filepath[:-3]+'dwg' - print 'exporting to %s' % filedwg - os.system('%s %s -acad13 -dwg' %(extCONV_PATH,filepath)) - #os.chdir(cwd) - os.remove(filepath) - Window.WaitCursor(0) - print ' finished in %.2f seconds. -----DONE-----' % (Blender.sys.time()-t) - Draw.PupMenu('DWG Exporter: job finished!| %s/%s objects exported in %.2f sek.' %(something_ready,selected_len, (Blender.sys.time()-t))) - else: - Window.WaitCursor(0) - print "Abort: selected objects dont match choosen export option, nothing exported!" - Draw.PupMenu('DXF Exporter: nothing exported!|selected objects dont match choosen export option!') - - -#------------------------------------------------------ -""" -v = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,\ -28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,46,47,58,59,60,61,62,63,64,91,92,93,94,96,\ -123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,\ -151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,\ -171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,\ -191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,\ -211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,\ -231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254] -invalid = ''.join([chr(i) for i in v]) -del v, i -""" -#TODO: validDXFr14 = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.' -validDXFr12 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_' - -#------------------------------------------------------ -def cleanName(name,valid): - validname = '' - for ch in name: - if ch not in valid: ch = '_' - validname += ch - return validname - -#------------------------------------------------------ -def validDXFr12name(str_name): - dxfname = str(str_name) - dxfname = dxfname[:NAMELENGTH_MAX].upper() - dxfname = cleanName(dxfname,validDXFr12) - return dxfname - -#print cleanName('dumka',validDXFr12) -#print validDXFr12name('dum 15%ka') - -#------------------------------------------------------ -def col2RGB(color): - return [int(floor(255*color[0])), - int(floor(255*color[1])), - int(floor(255*color[2]))] - -global dxfColors -dxfColors=None - -#------------------------------------------------------ -def col2DXF(rgbcolor): - global dxfColors - if dxfColors is None: - from dxfColorMap import color_map - dxfColors = [(tuple(color),idx) for idx, color in color_map.iteritems()] - dxfColors.sort() - entry = (tuple(rgbcolor), -1) - dxfColors.append(entry) - dxfColors.sort() - i = dxfColors.index(entry) - dxfColors.pop(i) - return dxfColors[i-1][1] - - - -# NEW UI -----#################################################----------------- -# ------------#################################################----------------- - -class Settings: #----------------------------------------------------------------- - """A container for all the export settings and objects. - - This is like a collection of globally accessable persistant properties and functions. - """ - # Optimization constants - MIN = 0 - MID = 1 - PRO = 2 - MAX = 3 - - def __init__(self, keywords, drawTypes): - """initialize all the important settings used by the export functions. - """ - self.obj_number = 1 #global object_number for progress_bar - - self.var = dict(keywords) #a dictionary of (key_variable:Value) control parameter - self.drawTypes = dict(drawTypes) #a dictionary of (entity_type:True/False) = import on/off for this entity_type - - self.var['colorFilter_on'] = False #deb:remi------------ - self.acceptedColors = [0,2,3,4,5,6,7,8,9, - 10 ] - - self.var['materialFilter_on'] = False #deb:remi------------ - self.acceptedLayers = ['3', - '0' - ] - - self.var['groupFilter_on'] = False #deb:remi------------ - self.acceptedLayers = ['3', - '0' - ] - - #self.var['objectFilter_on'] = 0 #deb:remi------------ - self.acceptedBlocks = ['WALL_1871', - 'BOX02' - ] - self.unwantedBlocks = ['BOX05', - 'BOX04' - ] - - - def update(self, keywords, drawTypes): - """update all the important settings used by the draw functions. - mostly used after loading parameters from INI-file - """ - - for k, v in keywords.iteritems(): - self.var[k] = v - #print 'deb:settings_update var %s= %s' %(k, self.var[k]) #-------------- - for t, v in drawTypes.iteritems(): - self.drawTypes[t] = v - #print 'deb:settings_update drawType %s= %s' %(t, self.drawTypes[t]) #-------------- - - self.drawTypes['arc'] = self.drawTypes['surface'] - self.drawTypes['circle'] = self.drawTypes['surface'] - self.drawTypes['ellipse'] = self.drawTypes['surface'] - self.drawTypes['trace'] = self.drawTypes['solid'] - self.drawTypes['insert'] = self.drawTypes['group'] - #self.drawTypes['vport'] = self.drawTypes['view'] - - #print 'deb:self.drawTypes', self.drawTypes #--------------- - - - def validate(self, drawing): - """Given the drawing, build dictionaries of Layers, Colors and Blocks. - """ - global oblist - #adjust the distance parameter to globalScale - if self.var['g_scale'] != 1.0: - self.var['dist_min'] = self.var['dist_min'] / self.var['g_scale'] - self.g_origin = Mathutils.Vector(self.var['g_originX'], self.var['g_originY'], self.var['g_originZ']) - - - def write(self, text, newline=True): - """Wraps the built-in print command in a optimization check. - """ - if self.var['optimization'] <= self.MID: - if newline: - print text - else: - print text, - - - def redraw(self): - """Update Blender if optimization level is low enough. - """ - if self.var['optimization'] <= self.MIN: - Blender.Redraw() - - - def progress(self, done, text): - """Wrapper for Blender.Window.DrawProgressBar. - """ - if self.var['optimization'] <= self.PRO: - progressbar = done * self.obj_number - Window.DrawProgressBar(progressbar, text) - #print 'deb:drawer done, progressbar: ', done, progressbar #----------------------- - - - -# GUI STUFF -----#################################################----------------- -from Blender.BGL import * - -EVENT_NONE = 1 -EVENT_START = 2 -EVENT_REDRAW = 3 -EVENT_LOAD_INI = 4 -EVENT_SAVE_INI = 5 -EVENT_RESET = 6 -EVENT_CHOOSE_INI = 7 -EVENT_CHOOSE_DXF = 8 -EVENT_HELP = 9 -EVENT_CAMERA = 10 -EVENT_LIGHT =11 -EVENT_DXF_DIR = 12 -EVENT_setCAMERA = 13 -# = 14 -EVENT_ORIGIN = 15 -EVENT_SCALE = 16 -EVENT_PRESET2D = 20 -EVENT_PRESET3D = 21 -EVENT_PRESETPLINE = 22 -EVENT_PRESETS = 23 -EVENT_EXIT = 100 - -GUI_A = {} # GUI-buttons dictionary for parameter -GUI_B = {} # GUI-buttons dictionary for drawingTypes - -# settings default, initialize ------------------------ - -#----------------------------------------------- -def prepareMenu(title,list): - menu = title - for i, item in enumerate(list): - menu += '|'+ item + ' %x' + str(i) - return menu - -#----------------------------------------------- -mesh_as_list = ["3DFACEs","POLYFACE","POLYLINE","LINEs","POINTs"] -mesh_as_menu = prepareMenu("export to: %t", mesh_as_list) - -curve_as_list = ["LINEs","POLYLINE","..LWPOLYLINE r14","..SPLINE r14","POINTs"] -curve_as_menu = prepareMenu("export to: %t", curve_as_list) - -surface_as_list = ["..3DFACEs","..POLYFACE","..POINTs","..NURBS"] -surface_as_menu = prepareMenu("export to: %t", surface_as_list) - -meta_as_list = ["..3DFACEs","..POLYFACE","..3DSOLID"] -meta_as_menu = prepareMenu("export to: %t", meta_as_list) - -text_as_list = ["TEXT","..MTEXT","..ATTRIBUT"] -text_as_menu = prepareMenu("export to: %t", text_as_list) - -empty_as_list = ["POINT","..INSERT","..XREF"] -empty_as_menu = prepareMenu("export to: %t|", empty_as_list) - -group_as_list = ["..GROUP","..BLOCK","..ungroup"] -group_as_menu = prepareMenu("export to: %t", group_as_list) - -parent_as_list = ["..BLOCK","..ungroup"] -parent_as_menu = prepareMenu("export to: %t", parent_as_list) - -proxy_as_list = ["..BLOCK","..XREF","..ungroup","..POINT"] -proxy_as_menu = prepareMenu("export to: %t", proxy_as_list) - -camera_as_list = ["..BLOCK","..A_CAMERA","VPORT","VIEW","POINT"] -camera_as_menu = prepareMenu("export to: %t", camera_as_list) - -lamp_as_list = ["..BLOCK","..A_LAMP","POINT"] -lamp_as_menu = prepareMenu("export to: %t", lamp_as_list) - -material_to_list= ["COLOR","LAYER","..LINESTYLE","..BLOCK","..XDATA","..INI-File"] -material_to_menu = prepareMenu("export to: %t", material_to_list) - -ltype_map_list= ["object_rgb","material_rgb","..map_table"] -ltype_map_menu = prepareMenu("export to: %t", ltype_map_list) - - - -layername_from_list = [LAYERNAME_DEF,"drawing_name","scene_name"] -layername_from_menu = prepareMenu("defaultLAYER: %t", layername_from_list) - -layerltype_def_list = ["CONTINUOUS","DOT","DASHED","DASHDOT","BORDER","HIDDEN"] -layerltype_def_menu = prepareMenu("LINETYPE set to: %t",layerltype_def_list) - -entitylayer_from_list = ["default_LAYER","obj.name","obj.layer","obj.material","obj.data.name","obj.data.material","..vertexgroup","..group","..map_table"] -entitylayer_from_menu = prepareMenu("entityLAYER from: %t", entitylayer_from_list) -#print 'deb: entitylayer_from_menu=', entitylayer_from_menu #-------------- - -entitycolor_from_list = ["default_COLOR","BYLAYER","BYBLOCK","obj.layer","obj.color","obj.material","obj.data.material","..map_table"] -entitycolor_from_menu = prepareMenu("entityCOLOR set to: %t",entitycolor_from_list) - -entityltype_from_list = ["default_LTYPE","BYLAYER","BYBLOCK","CONTINUOUS","DOT","DASHED","DASHDOT","BORDER","HIDDEN"] -entityltype_from_menu = prepareMenu("entityCOLOR set to: %t",entityltype_from_list) - -#dxf-LINE,ARC,CIRCLE,ELLIPSE - -g_scale_list = ''.join(( - 'scale factor: %t', - '|user def. %x12', - '|yard to m %x8', - '|feet to m %x7', - '|inch to m %x6', - '| x 100000 %x5', - '| x 10000 %x4', - '| x 1000 %x3', - '| x 100 %x2', - '| x 10 %x1', - '| x 1 %x0', - '| x 0.1 %x-1', - '| x 0.01 %x-2', - '| x 0.001 %x-3', - '| x 0.0001 %x-4', - '| x 0.00001 %x-5')) - -#print 'deb: g_scale_list', g_scale_list #----------- - -dxfFileName = Draw.Create("") -iniFileName = Draw.Create(INIFILE_DEFAULT_NAME + INIFILE_EXTENSION) -user_preset = 0 -config_UI = Draw.Create(0) #switch_on/off extended config_UI -g_scale_as = Draw.Create(int(log10(G_SCALE))) - - -keywords_org = { - 'optimization': 2, - 'dummy_on' : 0, - - 'xref_on' : 1, - 'block_nn': 0, - - 'paper_space_on': 0, - 'layFrozen_on': 0, - 'objectFilter_on': 0, - 'materialFilter_on': 0, - 'colorFilter_on': 0, - 'groupFilter_on': 0, - - 'only_selected_on': ONLYSELECTED, - 'only_visible_on': ONLYVISIBLE, - 'projection_on' : PROJECTION, - 'hidden_lines_on': HIDDEN_LINES, - 'shadows_on' : SHADOWS, - 'light_on' : 1, - 'outputDWG_on' : OUTPUT_DWG, - 'to_polyline_on': POLYLINES, - 'to_polyface_on': POLYFACES, - 'instances_on': INSTANCES, - 'apply_modifiers_on': APPLY_MODIFIERS, - 'include_duplis_on': INCLUDE_DUPLIS, - 'camera_selected': CAMERA, - - 'g_originX' : G_ORIGIN[0], - 'g_originY' : G_ORIGIN[1], - 'g_originZ' : G_ORIGIN[2], - 'g_origin_on': 0, - 'g_scale' : float(G_SCALE), -# 'g_scale_as': int(log10(G_SCALE)), # 0, - 'g_scale_on': 0, - 'Z_force_on': 0, - 'Z_elev': float(ELEVATION), - - - 'prefix_def' : PREFIX, - 'layername_def' : LAYERNAME_DEF, - 'layercolor_def': LAYERCOLOR_DEF, - 'layerltype_def': LAYERLTYPE_DEF, - 'entitylayer_from': 5, - 'entitycolor_from': 1, - 'entityltype_from' : 1, - - 'material_on': 1, - 'material_to': 2, - 'fill_on' : 1, - - 'mesh_as' : 1, - 'curve_as' : 1, - 'surface_as' : 1, - 'meta_as' : 1, - 'text_as' : 0, - 'empty_as' : 0, - 'group_as' : 0, - 'parent_as' : 0, - 'proxy_as' : 0, - 'camera_as': 3, - 'lamp_as' : 2, - } - -drawTypes_org = { - 'bmesh' : 1, - 'bcurve': 1, - 'surface': 0, - 'bmeta' : 0, - 'text' : 1, - 'empty' : 1, - 'group' : 1, - 'parent': 1, - 'proxy' : 0, - 'camera': 0, - 'lamp' : 0, - -# 'view' : 0, - } - -# creating of GUI-buttons -# GUI_A - GUI-buttons dictionary for parameter -# GUI_B - GUI-buttons dictionary for drawingTypes -for k, v in keywords_org.iteritems(): - GUI_A[k] = Draw.Create(v) -for k, v in drawTypes_org.iteritems(): - GUI_B[k] = Draw.Create(v) -#print 'deb:init GUI_A: ', GUI_A #--------------- -#print 'deb:init GUI_B: ', GUI_B #--------------- - -model_space_on = Draw.Create(1) - -# initialize settings-object controls how dxf entities are drawn -settings = Settings(keywords_org, drawTypes_org) - - -def update_RegistryKey(key, item): # - """updates key in Blender.Registry - """ - cache = True # data is also saved to a file - rdict = Registry.GetKey('DXF_Exporter', cache) - if not rdict: rdict = {} - if item: - rdict[key] = item - Registry.SetKey('DXF_Exporter', rdict, cache) - #print 'deb:update_RegistryKey rdict', rdict #--------------- - - -def check_RegistryKey(key): - """ check if the key is already there (saved on a previous execution of this script) - """ - cache = True # data is also saved to a file - rdict = Registry.GetKey('DXF_Exporter', cache) - #print 'deb:check_RegistryKey rdict:', rdict #---------------- - if rdict: # if found, get the values saved there - try: - item = rdict[key] - return item - except: - #update_RegistryKey() # if data isn't valid rewrite it - pass - -def saveConfig(): #--todo----------------------------------------------- - """Save settings/config/materials from GUI to INI-file. - - Write all config data to INI-file. - """ - global iniFileName - - iniFile = iniFileName.val - #print 'deb:saveConfig inifFile: ', inifFile #---------------------- - if iniFile.lower().endswith(INIFILE_EXTENSION): - - #--todo-- sort key.list for output - #key_list = GUI_A.keys().val - #key_list.sort() - #for key in key_list: - # l_name, l_data = key, GUI_A[key].val - # list_A - - output_str = '[%s,%s]' %(GUI_A, GUI_B) - if output_str =='None': - Draw.PupMenu('DXF-Exporter: INI-file: Alert!%t|no config-data present to save!') - else: - if Blender.sys.exists(iniFile): - f = file(iniFile, 'r') - header_str = f.readline() - f.close() - if header_str.startswith(INIFILE_HEADER[0:13]): - if Draw.PupMenu(' OK ? %t|SAVE OVER: ' + '\'%s\'' %iniFile) == 1: - save_ok = True - else: save_ok = False - elif Draw.PupMenu(' OK ? %t|SAVE OVER: ' + '\'%s\'' %iniFile + - '|Alert: this file has no valid ImportDXF-header| ! it may belong to another aplication !') == 1: - save_ok = True - else: save_ok = False - else: save_ok = True - - if save_ok: - # replace: ',' -> ',\n' - # replace: '{' -> '\n{\n' - # replace: '}' -> '\n}\n' - output_str = ',\n'.join(output_str.split(',')) - output_str = '\n}'.join(output_str.split('}')) - output_str = '{\n'.join(output_str.split('{')) - try: - f = file(iniFile, 'w') - f.write(INIFILE_HEADER + '\n# this is a comment line\n') - f.write(output_str) - f.close() - #Draw.PupMenu('DXF-Exporter: INI-file: Done!%t|config-data saved in ' + '\'%s\'' %iniFile) - except: - Draw.PupMenu('DXF-Exporter: INI-file: Error!%t|failure by writing to ' + '\'%s\'|no config-data saved!' %iniFile) - - else: - Draw.PupMenu('DXF-Exporter: INI-file: Alert!%t|no valid name/extension for INI-file selected!') - print "DXF-Exporter: Alert!: no valid INI-file selected." - if not iniFile: - if dxfFileName.val.lower().endswith('.dxf'): - iniFileName.val = dxfFileName.val[0:-4] + INIFILE_EXTENSION - - -def loadConfig(): #remi--todo----------------------------------------------- - """Load settings/config/materials from INI-file. - - TODO: Read material-assignements from config-file. - """ - #20070724 buggy Window.FileSelector(loadConfigFile, 'Load config data from INI-file', inifilename) - global iniFileName, GUI_A, GUI_B - - iniFile = iniFileName.val - update_RegistryKey('iniFileName', iniFile) - #print 'deb:loadConfig iniFile: ', iniFile #---------------------- - if iniFile.lower().endswith(INIFILE_EXTENSION) and Blender.sys.exists(iniFile): - f = file(iniFile, 'r') - header_str = f.readline() - if header_str.startswith(INIFILE_HEADER): - data_str = f.read() - f.close() - #print 'deb:loadConfig data_str from %s: \n' %iniFile , data_str #----------------- - data = eval(data_str) - for k, v in data[0].iteritems(): - try: GUI_A[k].val = v - except: GUI_A[k] = Draw.Create(v) - for k, v in data[1].iteritems(): - try: GUI_B[k].val = v - except: GUI_B[k] = Draw.Create(v) - else: - f.close() - Draw.PupMenu('DXF-Exporter: INI-file: Alert!%t|no valid header in INI-file: ' + '\'%s\'' %iniFile) - else: - Draw.PupMenu('DXF-Exporter: INI-file: Alert!%t|no valid INI-file selected!') - print "DXF-Exporter: Alert!: no valid INI-file selected." - if not iniFileName: - if dxfFileName.val.lower().endswith('.dxf'): - iniFileName.val = dxfFileName.val[0:-4] + INIFILE_EXTENSION - - - -def updateConfig(keywords, drawTypes): #----------------------------------------------- - """updates GUI_settings with given dictionaries - - """ - global GUI_A, GUI_B - #print 'deb:lresetDefaultConfig keywords_org: \n', keywords_org #--------- - for k, v in keywords.iteritems(): - GUI_A[k].val = v - for k, v in drawTypes.iteritems(): - GUI_B[k].val = v - -def resetDefaultConfig(): #----------------------------------------------- - """Resets settings/config/materials to defaults. - - """ - #print 'deb:lresetDefaultConfig keywords_org: \n', keywords_org #--------- - updateConfig(keywords_org, drawTypes_org) - - -def presetConfig_polyline(activate): #----------------------------------------------- - """Sets settings/config for polygon representation: POLYLINE(FACE) or LINEs/3DFACEs. - - """ - global GUI_A - if activate: - GUI_A['to_polyline_on'].val = 1 - GUI_A['mesh_as'].val = 1 - GUI_A['curve_as'].val = 1 - else: - GUI_A['to_polyline_on'].val = 0 - GUI_A['mesh_as'].val = 0 - GUI_A['curve_as'].val = 0 - -def resetDefaultConfig_2D(): #----------------------------------------------- - """Sets settings/config/materials to defaults 2D. - - """ - keywords2d = { - 'projection_on' : 1, - 'fill_on' : 1, - 'text_as' : 0, - 'group_as' : 0, - } - - drawTypes2d = { - 'bmesh' : 1, - 'bcurve': 1, - 'surface':0, - 'bmeta' : 0, - 'text' : 1, - 'empty' : 1, - 'group' : 1, - 'parent' : 1, - #'proxy' : 0, - #'camera': 0, - #'lamp' : 0, - - } - presetConfig_polyline(1) - updateConfig(keywords2d, drawTypes2d) - -def resetDefaultConfig_3D(): #----------------------------------------------- - """Sets settings/config/materials to defaults 3D. - - """ - keywords3d = { - 'projection_on' : 0, - 'fill_on' : 0, - 'text_as' : 0, - 'group_as' : 0, - } - - drawTypes3d = { - 'bmesh' : 1, - 'bcurve': 1, - 'surface':0, - 'bmeta' : 0, - 'text' : 0, - 'empty' : 1, - 'group' : 1, - 'parent' : 1, - #'proxy' : 0, - #'camera': 1, - #'lamp' : 1, - } - presetConfig_polyline(1) - updateConfig(keywords3d, drawTypes3d) - - -def inputGlobalScale(): - """Pop-up UI-Block for global scale factor - """ - global GUI_A - #print 'deb:inputGlobalScale ##########' #------------ - x_scale = Draw.Create(GUI_A['g_scale'].val) - block = [] - #block.append("global translation vector:") - block.append(("", x_scale, 0.0, 10000000.0)) - - retval = Draw.PupBlock("set global scale factor:", block) - - GUI_A['g_scale'].val = float(x_scale.val) - - -def inputOriginVector(): - """Pop-up UI-Block for global translation vector - """ - global GUI_A - #print 'deb:inputOriginVector ##########' #------------ - x_origin = Draw.Create(GUI_A['g_originX'].val) - y_origin = Draw.Create(GUI_A['g_originY'].val) - z_origin = Draw.Create(GUI_A['g_originZ'].val) - block = [] - #block.append("global translation vector:") - block.append(("X: ", x_origin, -100000000.0, 100000000.0)) - block.append(("Y: ", y_origin, -100000000.0, 100000000.0)) - block.append(("Z: ", z_origin, -100000000.0, 100000000.0)) - - retval = Draw.PupBlock("set global translation vector:", block) - - GUI_A['g_originX'].val = x_origin.val - GUI_A['g_originY'].val = y_origin.val - GUI_A['g_originZ'].val = z_origin.val - - -def update_globals(): #----------------------------------------------------------------- - """ update globals if GUI_A changed - """ - global ONLYSELECTED,ONLYVISIBLE, DEBUG,\ - PROJECTION, HIDDEN_LINES, CAMERA, \ - G_SCALE, G_ORIGIN,\ - PREFIX, LAYERNAME_DEF, LAYERCOLOR_DEF, LAYERLTYPE_DEF,\ - APPLY_MODIFIERS, INCLUDE_DUPLIS,\ - OUTPUT_DWG - #global POLYLINES - - ONLYSELECTED = GUI_A['only_selected_on'].val - ONLYVISIBLE = GUI_A['only_visible_on'].val - """ - POLYLINES = GUI_A['to_polyline_on'].val - if GUI_A['curve_as'].val==1: POLYLINES=1 - else: POLYLINES=0 - """ - - if GUI_A['optimization'].val==0: DEBUG = 1 - else: DEBUG = 0 - PROJECTION = GUI_A['projection_on'].val - HIDDEN_LINES = GUI_A['hidden_lines_on'].val - CAMERA = GUI_A['camera_selected'].val - G_SCALE = GUI_A['g_scale'].val - if GUI_A['g_origin_on'].val: - G_ORIGIN[0] = GUI_A['g_originX'].val - G_ORIGIN[1] = GUI_A['g_originY'].val - G_ORIGIN[2] = GUI_A['g_originZ'].val - if GUI_A['g_scale_on'].val: - G_ORIGIN[0] *= G_SCALE - G_ORIGIN[1] *= G_SCALE - G_ORIGIN[2] *= G_SCALE - - PREFIX = GUI_A['prefix_def'].val - LAYERNAME_DEF = GUI_A['layername_def'].val - LAYERCOLOR_DEF = GUI_A['layercolor_def'].val - LAYERLTYPE_DEF = layerltype_def_list[GUI_A['layerltype_def'].val] - - APPLY_MODIFIERS = GUI_A['apply_modifiers_on'].val - INCLUDE_DUPLIS = GUI_A['include_duplis_on'].val - OUTPUT_DWG = GUI_A['outputDWG_on'].val - #print 'deb: GUI HIDDEN_LINES=', HIDDEN_LINES #--------- - #print 'deb: GUI GUI_A: ', GUI_A['hidden_lines_on'].val #--------------- - #print 'deb: GUI GUI_B: ', GUI_B #--------------- - - -def draw_UI(): #----------------------------------------------------------------- - """ Draw startUI and setup Settings. - """ - global GUI_A, GUI_B #__version__ - global user_preset, iniFileName, dxfFileName, config_UI, g_scale_as - global model_space_on - global SCROLL - - global mPAN_X, menu_orgX, mPAN_Xmax - global mPAN_Y, menu_orgY, mPAN_Ymax - global menu__Area, headerArea, screenArea, scrollArea - - size=Buffer(GL_FLOAT, 4) - glGetFloatv(GL_SCISSOR_BOX, size) #window X,Y,sizeX,sizeY - size= size.list - #print '-------------size:', size #-------------------------- - for s in [0,1,2,3]: size[s]=int(size[s]) - window_Area = [0,0,size[2],size[3]-2] - scrollXArea = [0,0,window_Area[2],15] - scrollYArea = [0,0,15,window_Area[3]] - - menu_orgX = -mPAN_X - #menu_orgX = 0 #scrollW - #if menu_pan: menu_orgX -= mPAN_X - if menu_orgX < -mPAN_Xmax: menu_orgX, mPAN_X = -mPAN_Xmax,mPAN_Xmax - if menu_orgX > 0: menu_orgX, mPAN_X = 0,0 - - menu_orgY = -mPAN_Y - #if menu_pan: menu_orgY -= mPAN_Y - if menu_orgY < -mPAN_Ymax: menu_orgY, mPAN_Y = -mPAN_Ymax,mPAN_Ymax - if menu_orgY > 0: menu_orgY, mPAN_Y = 0,0 - - - menu_margin = 10 - butt_margin = 10 - common_column = int((window_Area[2] - (3 * butt_margin) - (2 * menu_margin)-30) / 4.0) - common_column = 70 - # This is for easy layout changes - but_0c = common_column #button 1.column width - but_1c = common_column #button 1.column width - but_2c = common_column #button 2.column - but_3c = common_column #button 3.column - menu_w = (3 * butt_margin) + but_0c + but_1c + but_2c + but_3c #menu width - - simple_menu_h = 260 - extend_menu_h = 345 - menu_h = simple_menu_h # y is menu upper.y - if config_UI.val: - menu_h += extend_menu_h - - mPAN_Xmax = menu_w-window_Area[2]+50 - mPAN_Ymax = menu_h-window_Area[3]+30 - - y = menu_h - x = 0 #menu left.x - x +=menu_orgX+20 - y +=menu_orgY+20 - - - but0c = x + menu_margin #buttons 0.column position.x - but1c = but0c + but_0c + butt_margin - but2c = but1c + but_1c + butt_margin - but3c = but2c + but_2c + butt_margin - but4c = but3c + but_3c - - # Here starts menu ----------------------------------------------------- - #glClear(GL_COLOR_BUFFER_BIT) - #glRasterPos2d(8, 125) - - - ui_box(x, y, x+menu_w+menu_margin*2, y-menu_h) - y -= 20 - Draw.Label("DXF(r12)-Exporter v" + __version__, but0c, y, menu_w, 20) - - if config_UI.val: - b0, b0_ = but0c, but_0c-20 + butt_margin - b1, b1_ = but1c-20, but_1c+20 - y_top = y - - y -= 10 - y -= 20 - Draw.BeginAlign() - GUI_B['bmesh'] = Draw.Toggle('Mesh', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['bmesh'].val, "Export Mesh-Objects on/off") - if GUI_B['bmesh'].val: - GUI_A['mesh_as'] = Draw.Menu(mesh_as_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['mesh_as'].val, "Select target DXF-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['bcurve'] = Draw.Toggle('Curve', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['bcurve'].val, "Export Curve-Objects on/off") - if GUI_B['bcurve'].val: - GUI_A['curve_as'] = Draw.Menu(curve_as_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['curve_as'].val, "Select target DXF-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['surface'] = Draw.Toggle('..Surface', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['surface'].val, "(*todo) Export Surface-Objects on/off") - if GUI_B['surface'].val: - GUI_A['surface_as'] = Draw.Menu(surface_as_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['surface_as'].val, "Select target DXF-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['bmeta'] = Draw.Toggle('..Meta', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['bmeta'].val, "(*todo) Export Meta-Objects on/off") - if GUI_B['bmeta'].val: - GUI_A['meta_as'] = Draw.Menu(meta_as_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['meta_as'].val, "Select target DXF-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['text'] = Draw.Toggle('Text', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['text'].val, "Export Text-Objects on/off") - if GUI_B['text'].val: - GUI_A['text_as'] = Draw.Menu(text_as_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['text_as'].val, "Select target DXF-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['empty'] = Draw.Toggle('Empty', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['empty'].val, "Export Empty-Objects on/off") - if GUI_B['empty'].val: - GUI_A['empty_as'] = Draw.Menu(empty_as_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['empty_as'].val, "Select target DXF-object") - Draw.EndAlign() - - y_down = y - # ----------------------------------------------- - - y = y_top - b0, b0_ = but2c, but_2c-20 + butt_margin - b1, b1_ = but3c-20, but_3c+20 - - y -= 10 - y -= 20 - Draw.BeginAlign() - GUI_B['group'] = Draw.Toggle('..Group', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['group'].val, "(*todo) Export Group-Relationships on/off") - if GUI_B['group'].val: - GUI_A['group_as'] = Draw.Menu(group_as_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['group_as'].val, "Select target DXF-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['parent'] = Draw.Toggle('..Parent', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['parent'].val, "(*todo) Export Parent-Relationships on/off") - if GUI_B['parent'].val: - GUI_A['parent_as'] = Draw.Menu(parent_as_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['parent_as'].val, "Select target DXF-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['proxy'] = Draw.Toggle('..Proxy', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['proxy'].val, "(*todo) Export Proxy-Objects on/off") - if GUI_B['proxy'].val: - GUI_A['proxy_as'] = Draw.Menu(proxy_as_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['proxy_as'].val, "Select target DXF-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['camera'] = Draw.Toggle('Camera', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['camera'].val, "(*wip) Export Camera-Objects on/off") - if GUI_B['camera'].val: - GUI_A['camera_as'] = Draw.Menu(camera_as_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['camera_as'].val, "Select target DXF-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['lamp'] = Draw.Toggle('Lamp', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['lamp'].val, "(*wip) Export Lamp-Objects on/off") - if GUI_B['lamp'].val: - GUI_A['lamp_as'] = Draw.Menu(lamp_as_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['lamp_as'].val, "Select target DXF-object") - Draw.EndAlign() - - - if y < y_down: y_down = y - # -----end supported objects-------------------------------------- - - y_top = y_down - y = y_top - y -= 10 - y -= 20 - but_ = menu_w / 6 - b0 = but0c + (menu_w - but_*6)/2 - Draw.BeginAlign() - #GUI_A['dummy_on'] = Draw.Toggle('-', EVENT_NONE, b0+but_*0, y, but_, 20, GUI_A['dummy_on'].val, "placeholder only on/off") - GUI_A['paper_space_on'] = Draw.Toggle('Paper', EVENT_NONE, b0+but_*0, y, but_, 20, GUI_A['paper_space_on'].val, "Export to Paper-Space, otherwise to Model-Space on/off") - GUI_A['layFrozen_on'] = Draw.Toggle ('..frozen', EVENT_NONE, b0+but_*1, y, but_, 20, GUI_A['layFrozen_on'].val, "(*todo) Support LAYER.frozen status on/off") - GUI_A['materialFilter_on'] = Draw.Toggle('..material', EVENT_NONE, b0+but_*2, y, but_, 20, GUI_A['materialFilter_on'].val, "(*todo) Material filtering on/off") - GUI_A['colorFilter_on'] = Draw.Toggle('..color', EVENT_NONE, b0+but_*3, y, but_, 20, GUI_A['colorFilter_on'].val, "(*todo) Color filtering on/off") - GUI_A['groupFilter_on'] = Draw.Toggle('..group', EVENT_NONE, b0+but_*4, y, but_, 20, GUI_A['groupFilter_on'].val, "(*todo) Group filtering on/off") - GUI_A['objectFilter_on'] = Draw.Toggle('..object', EVENT_NONE, b0+but_*5, y, but_, 20, GUI_A['objectFilter_on'].val, "(*todo) Object filtering on/off") - Draw.EndAlign() - - # -----end filters-------------------------------------- - - b0, b0_ = but0c, but_0c + butt_margin - b1, b1_ = but1c, but_1c - - y -= 10 - y -= 20 - Draw.BeginAlign() - GUI_A['g_origin_on'] = Draw.Toggle('Location', EVENT_REDRAW, b0, y, b0_, 20, GUI_A['g_origin_on'].val, "Global relocate all objects on/off") - if GUI_A['g_origin_on'].val: - tmp = Draw.PushButton('=', EVENT_ORIGIN, b1, y, 20, 20, "Edit relocation-vector (x,y,z in DXF units)") - origin_str = '(%.4f, %.4f, %.4f)' % ( - GUI_A['g_originX'].val, - GUI_A['g_originY'].val, - GUI_A['g_originZ'].val - ) - tmp = Draw.Label(origin_str, b1+20, y, 300, 20) - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_A['g_scale_on'] = Draw.Toggle('Scale', EVENT_REDRAW, b0, y, b0_, 20, GUI_A['g_scale_on'].val, "Global scale all objects on/off") - if GUI_A['g_scale_on'].val: - g_scale_as = Draw.Menu(g_scale_list, EVENT_SCALE, b1, y, 45, 20, g_scale_as.val, "Factor for scaling the DXFdata") - if g_scale_as.val == 12: - pass - else: - if g_scale_as.val == 6: #scale inches to meters - GUI_A['g_scale'].val = 0.0254000 - elif g_scale_as.val == 7: #scale feets to meters - GUI_A['g_scale'].val = 0.3048000 - elif g_scale_as.val == 8: #scale yards to meters - GUI_A['g_scale'].val = 0.9144000 - else: - GUI_A['g_scale'].val = 10.0 ** int(g_scale_as.val) - scale_float = GUI_A['g_scale'].val - if scale_float < 0.000001 or scale_float > 1000000: - scale_str = ' = %s' % GUI_A['g_scale'].val - else: - scale_str = ' = %.6f' % GUI_A['g_scale'].val - Draw.Label(scale_str, b1+45, y, 200, 20) - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_A['Z_force_on'] = Draw.Toggle('Elevation', EVENT_REDRAW, b0, y, b0_, 20, GUI_A['Z_force_on'].val, "Overwrite Z-coordinates (flatten geometry) on/off") - if GUI_A['Z_force_on'].val: - GUI_A['Z_elev'] = Draw.Number('', EVENT_NONE, b1, y, b1_, 20, GUI_A['Z_elev'].val, -1000, 1000, "Set value for default Z-coordinate (in DXF units)") - Draw.EndAlign() - - """ - y -= 30 - Draw.BeginAlign() - GUI_A['material_on'] = Draw.Toggle('.material', EVENT_REDRAW, b0, y, b0_-20, 20, GUI_A['material_on'].val, "Support for material assignment on/off") - if GUI_A['material_on'].val: - GUI_A['material_to'] = Draw.Menu(material_to_menu, EVENT_NONE, b1-20, y, b1_+20, 20, GUI_A['material_to'].val, "Material assigned to?") - Draw.EndAlign() - """ - - #b0, b0_ = but0c, but_0c + butt_margin - b0, b0_ = but0c, 50 - b1, b1_ = b0+b0_, but_0c-b0_+ but_1c + butt_margin - b2, b2_ = but2c, but_2c - b3, b3_ = but3c, but_3c - - y -= 30 - Draw.Label('Output:', b0, y, b0_, 20) - Draw.Label('LAYER:', b1, y, b1_, 20) - Draw.Label('COLOR:', b2, y, b2_, 20) - Draw.Label('LINETYPE:', b3, y, b3_, 20) - #Draw.Label('LINESIZE:', b4, y, b4_, 20) - - y -= 20 - Draw.BeginAlign() - GUI_A['prefix_def'] = Draw.String('', EVENT_NONE, b0, y, b0_, 20, GUI_A['prefix_def'].val, 10, "Type Prefix for LAYERs") - GUI_A['layername_def'] = Draw.String('', EVENT_NONE, b1, y, b1_, 20, GUI_A['layername_def'].val, 10, "Type default LAYER name") - GUI_A['layercolor_def'] = Draw.Number('', EVENT_NONE, b2, y, b2_, 20, GUI_A['layercolor_def'].val, 1, 255, "Set default COLOR. (0=BYBLOCK,256=BYLAYER)") - GUI_A['layerltype_def'] = Draw.Menu(layerltype_def_menu, EVENT_NONE, b3, y, b3_, 20, GUI_A['layerltype_def'].val, "Set default LINETYPE") - Draw.EndAlign() - - y -= 25 - Draw.Label('Style:', b0, y, b0_, 20) - Draw.BeginAlign() - GUI_A['entitylayer_from'] = Draw.Menu(entitylayer_from_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['entitylayer_from'].val, "entity LAYER assigned to?") - GUI_A['entitycolor_from'] = Draw.Menu(entitycolor_from_menu, EVENT_NONE, b2, y, b2_, 20, GUI_A['entitycolor_from'].val, "entity COLOR assigned to?") - GUI_A['entityltype_from'] = Draw.Menu(entityltype_from_menu, EVENT_NONE, b3, y, b3_, 20, GUI_A['entityltype_from'].val, "Set entity LINETYPE") - Draw.EndAlign() - - y -= 10 - - y_down = y - # -----end material,translate,scale------------------------------------------ - - - #-------------------------------------- - y_top = y_down - y = y_top - - y -= 30 - Draw.BeginAlign() - Draw.PushButton('INI file >', EVENT_CHOOSE_INI, but0c, y, but_0c, 20, 'Select INI-file with file selector') - iniFileName = Draw.String(' :', EVENT_NONE, but1c, y, menu_w-but_1c-60, 20, iniFileName.val, FILENAME_MAX, "Write here the name of the INI-file") - but = but4c-60 - Draw.PushButton('#', EVENT_PRESETS, but, y, 20, 20, "Toggle Preset-INI-files") - Draw.PushButton('L', EVENT_LOAD_INI, but+20, y, 20, 20, 'Loads configuration from selected ini-file: %s' % iniFileName.val) - Draw.PushButton('S', EVENT_SAVE_INI, but+40, y, 20, 20, 'Saves configuration to selected ini-file: %s' % iniFileName.val) - Draw.EndAlign() - - bm = butt_margin/2 - - y -= 10 - y -= 20 - Draw.BeginAlign() - Draw.PushButton('DXFfile >', EVENT_CHOOSE_DXF, but0c, y, but_0c, 20, 'Select DXF-file with file selector') - dxfFileName = Draw.String(' :', EVENT_NONE, but1c, y, menu_w-but_0c-menu_margin, 20, dxfFileName.val, FILENAME_MAX, "Type path/name of output DXF-file") - Draw.EndAlign() - - y -= 30 - config_UI = Draw.Toggle('CONFIG', EVENT_REDRAW, but0c, y, but_0c+bm, 20, config_UI.val, 'Advanced configuration on/off' ) - Draw.BeginAlign() - but, but_ = but1c, but_1c+bm - but_ /= 3 - Draw.PushButton('X', EVENT_RESET, but, y, 15, 20, "Reset configuration to defaults") - Draw.PushButton('2D', EVENT_PRESET2D, but+but_, y, but_, 20, 'Set to standard configuration for 2D export') - Draw.PushButton('3D', EVENT_PRESET3D, but+(but_*2), y, but_, 20, 'Set to standard configuration for 3D import') - Draw.EndAlign() - - - y -= 30 - b0, b0_ = but0c, but_0c + butt_margin +but_1c - GUI_A['only_selected_on'] = Draw.Toggle('Export Selection', EVENT_NONE, b0, y, b0_, 20, GUI_A['only_selected_on'].val, "Export only selected geometry on/off") - b0, b0_ = but2c, but_2c + butt_margin + but_3c - Draw.BeginAlign() - GUI_A['projection_on'] = Draw.Toggle('2d Projection', EVENT_REDRAW, b0, y, b0_, 20, GUI_A['projection_on'].val, "Export a 2d Projection according 3d-View or Camera-View on/off") - if GUI_A['projection_on'].val: - GUI_A['camera_selected'] = Draw.Menu(MenuCAMERA, EVENT_CAMERA, b0, y-20, b0_-20, 20, GUI_A['camera_selected'].val, 'Choose the camera to be rendered') - Draw.PushButton('>', EVENT_setCAMERA, b0+b0_-20, y-20, 20, 20, 'switch to selected Camera - make it active') - GUI_A['hidden_lines_on'] = Draw.Toggle('Remove backFaces', EVENT_NONE, b0, y-40, b0_, 20, GUI_A['hidden_lines_on'].val, "Filter out backFaces on/off") - #GUI_A['shadows_on'] = Draw.Toggle('..Shadows', EVENT_REDRAW, b0, y-60, but_2c, 20, GUI_A['shadows_on'].val, "(*todo) Shadow tracing on/off") - #GUI_A['light_on'] = Draw.Menu(MenuLIGHT, EVENT_LIGHT, but3c, y-60, but_3c, 20, GUI_A['light_on'].val, '(*todo) Choose the light source(sun) to be rendered') - Draw.EndAlign() - - y -= 20 - b0, b0_ = but0c, but_0c + butt_margin +but_1c - GUI_A['only_visible_on'] = Draw.Toggle('Visible only', EVENT_PRESETPLINE, b0, y, b0_, 20, GUI_A['only_visible_on'].val, "Export only from visible layers on/off") - #b0, b0_ = but2c, but_2c + butt_margin + but_3c - - y -= 20 - b0, b0_ = but0c, but_0c + butt_margin +but_1c - GUI_A['to_polyline_on'] = Draw.Toggle('POLYLINE-Mode', EVENT_PRESETPLINE, b0, y, b0_, 20, GUI_A['to_polyline_on'].val, "Export to POLYLINE/POLYFACEs, otherwise to LINEs/3DFACEs on/off") - #b0, b0_ = but2c, but_2c + butt_margin + but_3c - - y -= 20 - b0, b0_ = but0c, but_0c + butt_margin +but_1c - GUI_A['instances_on'] = Draw.Toggle('Instances as BLOCKs', EVENT_NONE, b0, y, b0_, 20, GUI_A['instances_on'].val, "Export instances (multi-users) of Mesh/Curve as BLOCK/INSERTs on/off") - #b0, b0_ = but2c, but_2c + butt_margin + but_3c - - y -= 20 - b0, b0_ = but0c, but_0c + butt_margin +but_1c - GUI_A['apply_modifiers_on'] = Draw.Toggle('Apply Modifiers', EVENT_NONE, b0, y, b0_, 20, GUI_A['apply_modifiers_on'].val, "Apply modifier stack to mesh objects before export on/off") - #b0, b0_ = but2c, but_2c + butt_margin + but_3c - - y -= 20 - b0, b0_ = but0c, but_0c + butt_margin +but_1c - GUI_A['include_duplis_on'] = Draw.Toggle('Include Duplis', EVENT_NONE, b0, y, b0_, 20, GUI_A['include_duplis_on'].val, "Export Duplicates (dupliverts, dupliframes, dupligroups) on/off") - #b0, b0_ = but2c, but_2c + butt_margin + but_3c - - - - y -= 30 - Draw.PushButton('EXIT', EVENT_EXIT, but0c, y, but_0c+bm, 20, '' ) - Draw.PushButton('HELP', EVENT_HELP, but1c, y, but_1c+bm, 20, 'goes to online-Manual on wiki.blender.org') - GUI_A['optimization'] = Draw.Number('', EVENT_NONE, but2c, y, 40, 20, GUI_A['optimization'].val, 0, 3, "Optimization Level: 0=Debug/Draw-in, 1=Verbose, 2=ProgressBar, 3=SilentMode") - GUI_A['outputDWG_on'] = Draw.Toggle('DWG*', EVENT_NONE, but2c, y+20, 40, 20, GUI_A['outputDWG_on'].val, "converts DXF to DWG (needs external converter) on/off") - - Draw.BeginAlign() - Draw.PushButton('START EXPORT', EVENT_START, but2c+40, y, but_2c-40+but_3c+butt_margin, 40, 'Start the export process. For Cancel go to console and hit Ctrl-C') - Draw.EndAlign() - - y -= 20 - #Draw.BeginAlign() - #Draw.Label(' ', but0c-menu_margin, y, menu_margin, 20) - #Draw.Label(LAB, but0c, y, menu_w, 20) - Draw.Label(LAB, 30, y, menu_w, 20) - #Draw.Label(' ', but0c+menu_w, y, menu_margin, 20) - #Draw.EndAlign() - - ui_scrollbarX(menu_orgX, menu_w+50, scrollXArea, c_fg, c_bg) - ui_scrollbarY(menu_orgY, menu_h+30, scrollYArea, c_fg, c_bg) - - - - -#-- END GUI Stuf----------------------------------------------------- - -c0=[0.2,0.2,0.2,0.0] -c1=[0.7,0.7,0.9,0.0] -c2=[0.71,0.71,0.71,0.0] -c3=[0.4,0.4,0.4,0.0] -c4=[0.95,0.95,0.9,0.0] -c5=[0.64,0.64,0.64,0] -c6=[0.75,0.75,0.75,0] -c7=[0.6,0.6,0.6,0] -c8=[1.0,0.0,0.0,0] -c9=[0.7,0.0,0.0,0] -c10=[0.64,0.81,0.81,0] -c11=[0.57,0.71,0.71,0] -c_nor= c5[:3] -c_act= c10[:3] -c_sel= c11[:3] -c_tx = c0[:3] -c_fg = c2[:3] -c_bg = c5[:3] - -def ui_rect(coords,color): - [X1,Y1,X2,Y2],[r,g,b] = coords,color - glColor3f(r,g,b) - glRecti(X1,Y1,X2,Y2) -def ui_rectA(coords,color): - [X1,Y1,X2,Y2],[r,g,b,a] = coords,color - glColor4f(r,g,b,a) - glRecti(X1,Y1,X2,Y2) #integer coords - #glRectf(X1,Y1,X2,Y2) #floating coords -def ui_line(coords,color): - [X1,Y1,X2,Y2],[r,g,b] = coords,color - glColor3f(r,g,b) - glBegin(GL_LINES) - glVertex2i(X1,Y1) - glVertex2i(X2,Y2) - glEnd() -def ui_panel(posX,posY,L,H,color): - [r,g,b] = color - ui_rect([posX+4,posY-4,posX+L+4,posY-H-4],[.55,.55,.55]) #1st shadow - ui_rect([posX+3,posY-3,posX+L+3,posY-H-3],[.45,.45,.45]) - ui_rect([posX+3,posY-3,posX+L+2,posY-H-2],[.30,.30,.30]) #2nd shadow - ui_rect([posX,posY-H,posX+L,posY],[r,g,b]) #Main - ui_rect([posX+3,posY-19,posX+L-3,posY-2],[.75*r,.75*g,.75*b]) #Titlebar - ui_line([posX+3,posY-19,posX+3,posY-2],[.25,.25,.25]) - ui_line([posX+4,posY-19,posX+4,posY-2],[(r+.75)/4,(g+.75)/4,(b+.75)/4]) - ui_line([posX+4,posY-2,posX+L-3,posY-2],[(r+.75)/4,(g+.75)/4,(b+.75)/4]) -def ui_box(x,y,xright,bottom): - color = [0.75, 0.75, 0.75] - coords = x+1,y+1,xright-1,bottom-1 - ui_rect(coords,color) - -def ui_scrollbarX(Focus,PanelH,Area, color_fg, color_bg): - # Area = ScrollBarArea - # point1=down/left, point2=top/right - P1X,P1Y,P2X,P2Y = Area - AreaH = P2X-P1X - if PanelH > AreaH: - Slider = int(AreaH * (AreaH / float(PanelH))) - if Slider<3: Slider = 3 #minimal slider heigh - posX = -int(AreaH * (Focus / float(PanelH))) - ui_rect([P1X,P1Y,P2X,P2Y], color_bg) - ui_rect([P1X+posX,P1Y+3,P1X+posX+Slider,P2Y-3], color_fg) - -def ui_scrollbarY(Focus,PanelH,Area, color_fg, color_bg): - # Area = ScrollBarArea - # point1=down/left, point2=top/right - P1X,P1Y,P2X,P2Y = Area - AreaH = P2Y-P1Y - if PanelH > AreaH: - Slider = int(AreaH * (AreaH / float(PanelH))) - if Slider<3: Slider = 3 #minimal slider heigh - posY = -int(AreaH * (Focus / float(PanelH))) - ui_rect([P1X,P1Y,P2X-1,P2Y], color_bg) - #ui_rect([P1X+3,P2Y-posY,P2X-4,P2Y-posY-Slider], color_fg) - ui_rect([P1X+3,P1Y+posY,P2X-4,P1Y+posY+Slider], color_fg) - - -#------------------------------------------------------------ -def dxf_callback(input_filename): - global dxfFileName - dxfFileName.val=input_filename -# dirname == Blender.sys.dirname(Blender.Get('filename')) -# update_RegistryKey('DirName', dirname) -# update_RegistryKey('dxfFileName', input_filename) - -def ini_callback(input_filename): - global iniFileName - iniFileName.val=input_filename - -#------------------------------------------------------------ -def getSpaceRect(): - __UI_RECT__ = Buffer(GL_FLOAT, 4) - glGetFloatv(GL_SCISSOR_BOX, __UI_RECT__) - __UI_RECT__ = __UI_RECT__.list - return (int(__UI_RECT__[0]), int(__UI_RECT__[1]), int(__UI_RECT__[2]), int(__UI_RECT__[3])) - -def getRelMousePos(mco, winRect): - # mco = Blender.Window.GetMouseCoords() - if pointInRect(mco, winRect): - return (mco[0] - winRect[0], mco[1] - winRect[1]) - return None - - -def pointInRect(pt, rect): - if rect[0] < pt[0] < rect[0]+rect[2] and\ - rect[1] < pt[1] < rect[1]+rect[3]: - return True - else: - return False - - - -#--- variables UI menu --------------------------- -mco = [0,0] # mouse coordinaten -mbX, mbY = 0,0 # mouse buffer coordinaten -scrollW = 20 # width of scrollbar -rowH = 20 # height of menu raw -menu__H = 2 * rowH +5 # height of menu bar -headerH = 1 * rowH # height of column header bar -scroll_left = True # position of scrollbar -menu_bottom = False # position of menu -edit_mode = False # indicator/activator -iconlib_mode = False # indicator/activator -icon_maps = [] #[['blenderbuttons.png',12,25,20,21], -#['referenceicons.png',12,25,20,21]] -help_text = False # indicator/activator -menu_pan = False # indicator/activator -compact_DESIGN = True # toggle UI -showLINK = True # toggle Links -filterList=[-1,-1,-1,-1,-1] -dubbleclik_delay = 0.25 - -PAN_X,PAN_Y = 0,0 # pan coordinates in characters -mPAN_X,mPAN_Y = 0,0 # manu pan coordinates in characters -menu_orgX = 0 -menu_orgY = 0 -mPAN_Xmax = 800 -mPAN_Ymax = 800 - - -#------------------------------------------------------------ -def event(evt, val): - global mbX, mbY, UP, UP0, scroll_pan, FOCUS_fix - global menu_bottom, scroll_left, mco - global PAN_X, PAN_Y, PAN_X0, PAN_Y0 - global mPAN_X, mPAN_Y, mPAN_X0, mPAN_Y0, menu_pan - - #if Blender.event: - # print 'Blender.event:%s, evt:%s' %(Blender.event, evt) #------------ - - if evt in (Draw.QKEY, Draw.ESCKEY) and not val: - print 'DXF-Exporter *** end ***' #--------------------- - Draw.Exit() - - elif val: - if evt==Draw.MIDDLEMOUSE: - mco2 = Window.GetMouseCoords() - relativeMouseCo = getRelMousePos(mco2, getSpaceRect()) - if relativeMouseCo != None: - #rect = [menu__X1,menu__Y1,menu__X2,menu__Y2] - if 1: #pointInRect(relativeMouseCo, menu__Area): - menu_pan = True - mPAN_X0 = mPAN_X - mPAN_Y0 = mPAN_Y - mco = mco2 - elif evt == Draw.MOUSEY or evt == Draw.MOUSEX: - if menu_pan: - mco2 = Window.GetMouseCoords() - mbX = mco2[0]-mco[0] - mbY = mco2[1]-mco[1] - mPAN_X = mPAN_X0 - mbX - mPAN_Y = mPAN_Y0 - mbY - #print mbX, mbY #-------------------- - Draw.Redraw() - elif evt == Draw.WHEELDOWNMOUSE: - mPAN_Y -= 80 - Draw.Redraw() - elif evt == Draw.WHEELUPMOUSE: - mPAN_Y += 80 - Draw.Redraw() - else: # = if val==False: - if evt==Draw.LEFTMOUSE: - scroll_pan = False - elif evt==Draw.MIDDLEMOUSE: - menu_pan = False - -def bevent(evt): - global config_UI, user_preset - global CAMERA, GUI_A - - ######### Manages GUI events - if (evt==EVENT_EXIT): - Draw.Exit() - print 'DXF-Exporter *** end ***' #--------------------- - elif (evt==EVENT_CHOOSE_INI): - Window.FileSelector(ini_callback, "INI-file Selection", '*.ini') - elif (evt==EVENT_REDRAW): - Draw.Redraw() - elif (evt==EVENT_RESET): - resetDefaultConfig() - Draw.Redraw() - elif (evt==EVENT_PRESET2D): - resetDefaultConfig_2D() - Draw.Redraw() - elif (evt==EVENT_PRESET3D): - resetDefaultConfig_3D() - Draw.Redraw() - elif evt in (EVENT_CAMERA,EVENT_LIGHT): - CAMERA = GUI_A['camera_selected'].val - if CAMERA==len(CAMERAS)+1: - doAllCameras = True - else: - pass #print 'deb: CAMERAS=',CAMERAS #---------------- - Draw.Redraw() - elif (evt==EVENT_setCAMERA): - if CAMERA<len(CAMERAS)+1: - gotoCAMERA() - - elif (evt==EVENT_SCALE): - if g_scale_as.val == 12: - inputGlobalScale() - if GUI_A['g_scale'].val < 0.00000001: - GUI_A['g_scale'].val = 0.00000001 - Draw.Redraw() - elif (evt==EVENT_ORIGIN): - inputOriginVector() - Draw.Redraw() - elif (evt==EVENT_PRESETPLINE): - presetConfig_polyline(GUI_A['to_polyline_on'].val) - Draw.Redraw() - elif (evt==EVENT_PRESETS): - user_preset += 1 - index = str(user_preset) - if user_preset > 5: user_preset = 0; index = '' - iniFileName.val = INIFILE_DEFAULT_NAME + index + INIFILE_EXTENSION - Draw.Redraw() - elif (evt==EVENT_HELP): - try: - import webbrowser - webbrowser.open('http://wiki.blender.org/index.php?title=Scripts/Manual/Export/autodesk_dxf') - except: - Draw.PupMenu('DXF-Exporter: HELP Alert!%t|no connection to manual-page on Blender-Wiki! try:|\ -http://wiki.blender.org/index.php?title=Scripts/Manual/Export/autodesk_dxf') - Draw.Redraw() - elif (evt==EVENT_LOAD_INI): - loadConfig() - Draw.Redraw() - elif (evt==EVENT_SAVE_INI): - saveConfig() - Draw.Redraw() - elif (evt==EVENT_DXF_DIR): - dxfFile = dxfFileName.val - dxfPathName = '' - if '/' in dxfFile: - dxfPathName = '/'.join(dxfFile.split('/')[:-1]) + '/' - elif '\\' in dxfFile: - dxfPathName = '\\'.join(dxfFile.split('\\')[:-1]) + '\\' - dxfFileName.val = dxfPathName + '*.dxf' -# dirname == Blender.sys.dirname(Blender.Get('filename')) -# update_RegistryKey('DirName', dirname) -# update_RegistryKey('dxfFileName', dxfFileName.val) - GUI_A['only_selected_on'].val = 1 - Draw.Redraw() - elif (evt==EVENT_CHOOSE_DXF): - filename = '' # '*.dxf' - if dxfFileName.val: filename = dxfFileName.val - Window.FileSelector(dxf_callback, "DXF-file Selection", filename) - elif (evt==EVENT_START): - dxfFile = dxfFileName.val - #print 'deb: dxfFile file: ', dxfFile #---------------------- - if E_M: dxfFileName.val, dxfFile = e_mode(dxfFile) #evaluation mode - update_RegistryKey('dxfFileName', dxfFileName.val) - update_globals() - if dxfFile.lower().endswith('*.dxf'): - if Draw.PupMenu('DXF-Exporter: OK?|will write multiple DXF-files, one for each Scene, in:|%s' % dxfFile) == 1: - global UI_MODE - UI_MODE = False - #TODO: multi_export(dxfFile[:-5]) # cut last 5 characters '*.dxf' - Draw.Redraw() - UI_MODE = True - else: - Draw.Redraw() - elif dxfFile.lower()[-4:] in ('.dxf','.dwg'): # and Blender.sys.exists(dxfFile): - print 'preparing for export ---' #Standard Mode: activated - filepath = dxfFile - sce = Scene.GetCurrent() - if ONLYSELECTED: sel_group = sce.objects.selected - else: sel_group = sce.objects - - if ONLYVISIBLE: - sel_group_temp = [] - layerlist = sce.getLayers() - for ob in sel_group: - for lay in ob.layers: - if lay in layerlist: - sel_group_temp.append(ob) - break - sel_group = sel_group_temp - - export_list = getObjectsAndDuplis(sel_group,MATRICES=True) - - if export_list: do_export(export_list, filepath) - else: - print "Abort: selection was empty, no object to export!" - Draw.PupMenu('DXF Exporter: nothing exported!|empty selection!') - else: - Draw.PupMenu('DXF-Exporter: Alert!%t|no valid DXF-file selected!') - print "DXF-Exporter: error, no valid DXF-file selected! try again" - Draw.Redraw() - - - - -def multi_export(DIR): #TODO: - """Imports all DXF-files from directory DIR. - - """ - global SCENE - batchTIME = Blender.sys.time() - #if #DIR == "": DIR = os.path.curdir - if DIR == "": DIR = Blender.sys.dirname(Blender.Get('filename')) - print 'Multifiles Import from %s' %DIR - files = \ - [Blender.sys.join(DIR, f) for f in os.listdir(DIR) if f.lower().endswith('.dxf')] - if not files: - print '...None DXF-files found. Abort!' - return - - i = 0 - for dxfFile in files: - i += 1 - print '\nDXF-file', i, 'of', len(files) #,'\nImporting', dxfFile - if ONLYSELECTED: - _dxf_file = dxfFile.split('/')[-1].split('\\')[-1] - _dxf_file = _dxf_file[:-4] # cut last char:'.dxf' - _dxf_file = _dxf_file[:NAMELENGTH_MAX] #? [-NAMELENGTH_MAX:]) - SCENE = Blender.Scene.New(_dxf_file) - SCENE.makeCurrent() - #or so? Blender.Scene.makeCurrent(_dxf_file) - #sce = bpy.data.scenes.new(_dxf_file) - #bpy.data.scenes.active = sce - else: - SCENE = Blender.Scene.GetCurrent() - SCENE.objects.selected = [] # deselect all - main(dxfFile) - #Blender.Redraw() - - print 'TOTAL TIME: %.6f' % (Blender.sys.time() - batchTIME) - print '\a\r', # beep when done - - -#----------------------------------------------------- -if __name__=='__main__': - - if DXF: - print '\n\n\n' - print 'DXF-Exporter v%s *** start ***' %(__version__) #--------------------- - print 'with Library %s' %(DXF.__version__) #--------------------- - if not DXF.copy: - print "DXF-Exporter: dxfLibrary.py script requires a full Python install" - Draw.PupMenu('Error%t|The dxfLibrary.py script requires a full Python install') - else: - #Window.FileSelector(dxf_export_ui, 'EXPORT DXF', Blender.sys.makename(ext='.dxf')) - # recall last used DXF-file and INI-file names - dxffilename = check_RegistryKey('dxfFileName') - #print 'deb:start dxffilename:', dxffilename #---------------- - if dxffilename: dxfFileName.val = dxffilename - else: - dirname = Blender.sys.dirname(Blender.Get('filename')) - #print 'deb:start dirname:', dirname #---------------- - dxfFileName.val = Blender.sys.join(dirname, '') - inifilename = check_RegistryKey('iniFileName') - if inifilename: iniFileName.val = inifilename - - updateMenuCAMERA() - updateCAMERA() - - Draw.Register(draw_UI, event, bevent) - -
\ No newline at end of file |