diff options
Diffstat (limited to 'release/scripts/import_dxf.py')
| -rw-r--r-- | release/scripts/import_dxf.py | 6225 |
1 files changed, 0 insertions, 6225 deletions
diff --git a/release/scripts/import_dxf.py b/release/scripts/import_dxf.py deleted file mode 100644 index b3bee11c464..00000000000 --- a/release/scripts/import_dxf.py +++ /dev/null @@ -1,6225 +0,0 @@ -#!BPY - -""" -Name: 'Autodesk DXF (.dxf .dwg)' -Blender: 249 -Group: 'Import' -Tooltip: 'Import for DWG/DXF geometry data.' -""" -__author__ = 'Kitsu(Ed Blake) & migius(Remigiusz Fiedler)' -__version__ = '1.12 - 2009.06.16 by migius' -__url__ = ["http://blenderartists.org/forum/showthread.php?t=84319", - "http://wiki.blender.org/index.php/Scripts/Manual/Import/DXF-3D"] -__email__ = ["migius(at)4d-vectors.de","Kitsune_e(at)yahoo.com"] -__bpydoc__ = """\ -This script imports objects from DWG/DXF (2d/3d) into Blender. - -This script imports 2d and 3d geometery from DXF files. -It supports DWG format too, with help of an external converter. -Supported DXF format versions: from (r2.5) r12 up to r2008. -Enhanced features are: -- configurable object filtering and geometry manipulation, -- configurable material pre-processing, -- DXF-code analyze and reporting. - -Supported DXF r12 objects: -LINE, -POINT, -SOLID, -TRACE, -TEXT, -INSERT (=block), -MINSERT (=array of blocks), -CIRCLE, -ARC, -3DFACE, -2d-POLYLINE (=in plane, incl. arc, variable-width, curve, spline), -3d-POLYLINE (=non-plane), -3d-POLYMESH, -3d-POLYFACE, -VIEW, VPORT -XREF (External Reference). - -Supported DXF>r12 objects: -ELLIPSE, -LWPOLYLINE (LightWeight Polyline), -SPLINE, -(todo v1.13) MLINE, -(todo v1.13) MTEXT - -Unsupported objects: -DXF r12: DIMENSION. -DXF>r12: GROUP, RAY/XLINE, LEADER, 3DSOLID, BODY, REGION, dynamic BLOCK - -Supported geometry: 2d and 3d DXF-objects. -Curves imported as Blender curves or meshes optionally. - -Supported layout modes: -"model space" is default, -"paper space" as option (= "layout views") - -Supported scene definition objects produced with AVE_RENDER: -scene: selection of lights assigned to the camera, -lights: DIRECT, OVERHEAD, SH_SPOT, -(wip v1.13 import of AVE_RENDER material definitions) - -Hierarchy: -Entire DXF BLOCK hierarchy is preserved after import into Blender -(BLOCKs as groups on layer19, INSERTs as dupliGroups on target layer). - -Supported properties: -visibility status, -frozen status, -thickness, -width, -color, -layer, -(todo v1.13: XDATA, grouped status) -It is recommended to use DXF-object properties for assign Blender materials. - -Notes: -- Recommend that you run 'RemoveDoubles' on each imported mesh after using this script -- Blocks are created on layer 19 then referenced at each insert point. -- support for DXF-files up to 160MB on systems with 1GB RAM -- DXF-files with over 1500 objects decrease import performance. -The problem is not the inefficiency of python-scripting but Blenders performance -in creating new objects in scene database - probably a database management problem. - -""" - -""" -History: - v1.0 - 2007/2008/2009 by migius - planned tasks: - -- (to see more, search for "--todo--" in script code) - -- command-line-mode/batch-mode - -- in-place-editing for dupliGroups - -- support for MLINE (is exported to r12 as BLOCK*Unnamed with LINEs) - -- support for MTEXT (is exported to r12 as TEXT???) - -- blender_object.properties['dxf_layer_name'] - -- better support for long dxf-layer-names - -- add configuration file.ini handles multiple material setups - -- added f_layerFilter - -- to-check: obj/mat/group/_mapping-idea from ideasman42 - -- curves: added "fill/non-fill" option for closed curves: CIRCLEs,ELLIPSEs,POLYLINEs - -- "normalize Z" option to correct non-planar figures - -- LINEs need "width" in 3d-space incl vGroups - -- support width_force for LINEs/ELLIPSEs = "solidify" - -- add better support for color_index BYLAYER=256, BYBLOCK=0 - -- bug: "oneMesh" produces irregularly errors - -- bug: Registry recall from hd_cache ?? only win32 bug?? - -- support DXF-definitions of autoshade: scene, lights and cameras - -- support ortho mode for VIEWs and VPORTs as cameras - - v1.12 - 2009.06.16 by migius - d7 fix for ignored BLOCKs (e.g. *X) which are members of other BLOCKs - v1.12 - 2009.05.27 by migius - d6 bugfix negative scaled INSERTs - isLeftHand(Matrix) check - v1.12 - 2009.05.26 by migius - d5 changed to the new 2.49 method Vector.cross() - d5 bugfix WORLDY(1,1,0) to (0,1,0) - v1.12 - 2009.04.11 by migius - d4 added DWG support, Stani Michiels idea for binding an extern DXF-DWG-converter - v1.12 - 2009.03.14 by migius - d3 removed all set()functions (problem with osx/python<2.4 reported by Blinkozo) - d3 code-cleaning - v1.12 - 2009.01.14 by migius - d2 temp patch for noname BLOCKS (*X,*U,*D) - v1.12 - 2008.11.16 by migius - d1 remove try_finally: cause not supported in python <2.5 - d1 add Bezier curves bevel radius support (default 1.0) - v1.12 - 2008.08.03 by migius - c2 warningfix: relocating of globals: layersmap, oblist - c2 modif UI: buttons newScene+targetLayer moved to start panel - v1.12 - 2008.07.04 by migius - c1 added control Curve's OrderU parameter - c1 modif UI: preset buttons X-2D-3D moved to start panel - b6 added handling exception of not registered LAYERs (Hammer-HL-editor DXF output) - b5 rebuild UI: global preset 2D for Curve-Import - b5 added UI-options: PL-MESH N+N plmesh_flip and normals_out - b5 added support for SPLINEs, added control OrderU parameter - b5 rewrote draw module for NURBS_curve and Bezier_curve - v1.12 - 2008.06.22 by migius - b4 change versioning system 1.0.12 -> 1.12 - b4 print at start version-info to console - b3 bugfix: ob.name conflict with existing meshes (different ob.name/mesh.name) - v1.0.12: 2008.05.24 by migius - b2 added support for LWPOLYLINEs - b2 added support for ProE in readerDXF.py - v1.0.12: 2008.02.08 by migius - b1 update: object = Object.Get(obname) -> f_getSceChild().getChildren() - a9 bugfix by non-existing tables views, vports, layers (Kai reported) - v1.0.12: 2008.01.17 by migius - a8 lately used INI-dir/filename persistently stored in Registry - a8 lately used DXF-dir/filename persistently stored in Registry - a7 fix missing layersmap{} for dxf-files without "section:layer" - a6 added support for XREF external referenced BLOCKs - a6 check for bug in AutoCAD2002:DXFr12export: ELLIPSE->POLYLINE_ARC fault angles - a6 support VIEWs and VPORTs as cameras: ortho and perspective mode - a6 save resources through ignoring unused BLOCKs (not-inserted or on frozen/blocked layers) - a6 added try_finally: f.close() for all IO-files - a6 added handling for TypeError raise - a5 bugfix f_getOCS for (0,0,z!=1.0) (ellipse in Kai's dxf) - a4 added to analyzeTool: report about VIEWs, VPORTs, unused/xref BLOCKs - a4 bugfix: individual support for 2D/3DPOLYLINE/POLYMESH - a4 added to UI: (*wip)BLOCK-(F): name filtering for BLOCKs - a4 added to UI: BLOCK-(n): filter noname/hatch BLOCKs *X... - a2 g_scale_as is no more GUI_A-variable - a2 bugfix "material": negative sign color_index - a2 added support for BLOCKs defined with origin !=(0,0,0) - a1 added 'global.reLocation-vector' option - - v1.0.11: 2007.11.24 by migius - c8 added 'curve_resolution_U' option - c8 added context_sensitivity for some UI-buttons - c8 bugfix ELLIPSE rotation, added closed_variant and caps - c7 rebuild UI: new layout, grouping and meta-buttons - c6 rewritten support for ELLIPSE mesh & curve representation - c6 restore selector-buttons for DXF-drawTypes: LINE & Co - c6 change header of INI/INF-files: # at begin - c6 apply scale(1,1,1) after glob.Scale for all mesh objects, not for curve objects. - c5 fixing 'material_on' option - c4 added "analyze DXF-file" UI-option: print LAYER/BLOCK-dependences into a textfile - c3 human-formating of data in INI-Files - c2 added "caps" for closed Bezier-curves - c2 added "set elevation" UI-option - c1 rewrite POLYLINE2d-arc-segments Bezier-interpreter - b9 many bugs fixed - b9 rewrite POLYLINE2d-arc-segments trimming (clean-trim) - b8 added "import from frozen layers" UI-option - b8 added "import from paper space" UI-option - b8 support Bezier curves for LINEs incl.thickness(0.0-10.0) - b8 added meshSmooth_on for circle/arc/polyline - b8 added vertexGroups for circle/arc - b7 added width_force for ARCs/CIRCLEs = "thin_box" option - b3 cleanup code, rename f_drawArc/Bulg->f_calcArc/Bulg - b2 fixing material assignment by LAYER+COLOR - b1 fixing Bezier curves representation of POLYLINEs-arc-segments - b0 added global_scale_presets: "yard/feet/inch to meter" - - v1.0.10: 2007.10.18 by migius - a6 bugfix CircleDrawCaps for OSX - a5 added two "curve_res" UI-buttons for Bezier curves representation - a5 improved Bezier curves representation of circles/arcs: correct handlers - a4 try to fix malformed endpoints of Blender curves of ARC/POLYLINE-arc segments. - a3 bugfix: open-POLYLINEs with end_point.loc==start_point.loc - a2 bugfix: f_transform for OCS=(0,0,-1) oriented objects - a1 added "fill_on=caps" option to draw top and bottom sides of CIRCLEs and ELLIPSEs - a1 rewrite f_CIRCLE.Draw: from Mesh.Primitive to Mesh - a1 bugfix "newScene"-mode: all Cylinders/Arcs were drawn at <0,0,0>location - - v1.0.beta09: 2007.09.02 by migius - g5 redesign UI: grouping of buttons - g3 update multi-import-mode: <*.*> button - g- added multi-import-mode: (path/*) for importing many dxf-files at once - g- added import into newScene - g- redesign UI: user presets, into newScene-import - f- cleanup code - f- bugfix: thickness for Bezier/Bsplines into Blender-curves - f- BlenderWiki documentation, on-line Manual - f- added import POLYLINE-Bsplines into Blender-NURBSCurves - f- added import POLYLINE-arc-segments into Blender-BezierCurves - f- added import POLYLINE-Bezier-curves into Blender-Curves - d5 rewrite: Optimization Levels, added 'directDrawing' - d4 added: f_set_thick(controlled by ini-parameters) - d4 bugfix: face-normals in objects with minus thickness - d4 added: placeholder'Empty'-size in f_Insert.draw - d3 rewrite f_Text.Draw: added support for all Text's parameters - d2 redesign: progressbar - e- tuning by ideasman42: better use of the Py API. - c- tuning by ideasman42 - b- rewrite f_Text.Draw rotation/transform - b- bugfix: POLYLINE-segment-intersection more reliable now - b- bugfix: circle:_thic, 'Empties':no material_assignment - b- added material assignment (from layer and/or color) - a- added empty, cylinder and UVsphere for POINTs - a- added support for 2d-POLYLINE: splines, fitted curves, fitted surfaces - a- redesign f_Drawer for block_definitions - a- rewrite import into Blender-Curve-Object - - v1.0.beta08 - 2007.07.27 by migius: "full 3d"-release - l- bugfix: solid_vgroups, clean:scene.objects.new() - l- redesign UI to standard Draw.Register+FileSelector, advanced_config_option - k- bugfix UI:fileSelect() for MacOSX os.listdir() - k- added reset/save/load for config-data - k- redesign keywords/drawTypes/Draw.Create_Buttons - j- new UI using UIBlock() with own FileSelector, cause problem Window.FileSelector() - i- rewritten Class:Settings for better config-parameter management - h- bugfix: face-normals in objects with minus thickness - h- added Vertex-Groups in POLYLINE and SOLID meshes, for easy material assignment - h- beautify code, whitespace->tabs - h- added settings.thic_force switch for forcing thickness - h- added "one Mesh" option for all entities from the same Layer, sorted in<br> - Vertex-Groups(color_name) (fewer objects = better import performance) - g- rewrote: insert-point-handle-object is a small tetrahedron - e- bugfix: closed-polymesh3d - - rewrote: UI, type_map.keys, f_drawer, all class_f_draw(added "settings" as attribut) - - added 2d/3d-support for Polyline_Width incl. angle intersection - beta07: 2007.06.19 by migius - - added 3d-support for LWPolylines - - added 2d/3d-support for Points - beta06: 2007.06.15 by migius - - cleanup code - - added 2d/3d-support for MINSERT=BlockArray in f_drawer, added f_rotXY_Vec - beta05: 2007.06.14 by migius - - added 2d/3d-support for 3d-PolyLine, PolyMesh and PolyFace - - added Global-Scale for size control of imported scenes - beta04: 2007.06.12 by migius - - rewrote the f_drawBulge for correct import the arc-segments of Polylines - beta03: 2007.06.10 by migius - - rewrote interface - beta02: 2007.06.09 by migius - - added 3d-support for Arcs and Circles - - added support for Object_Thickness(=height) - beta01: 2007.06.08 by migius - - added 3d-support for Blocks/Inserts within nested-structures - - rewrote f_transform for correct 3d-location/3d-rotation - - added 3d-support Lines, 3dFaces - - added 2d+3d-support for Solids and Traces - - v0.9 - 2007.01 by kitsu: (for 2.43) - - first draft of true POLYLINE import - - - - v0.8 - 2006.12 by kitsu: - - first draft of object space coordinates OCS import - - - - v0.5b - 2006.10 by kitsu: (for 2.42a) - - dxfReader.py - - color_map.py - -""" - -# -------------------------------------------------------------------------- -# DXF Import v1.0 by Ed Blake (AKA kitsu) and 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, BezTriple, Draw, Registry, sys,\ -Text3d, Window, Mesh, Material, Group, Curve -#from Blender.Mathutils import Vector, Matrix -#import bpy #not used yet -#import BPyMessages - -from dxfReader import readDXF -#from dxfReader import get_name, get_layer -from dxfReader import Object as dxfObject -from dxfColorMap import color_map -from math import log10, sqrt, radians, degrees, atan, cos, sin - -# osx-patch by Blinkozo -#todo: avoid additional modules, prefer Blender-build-in test routines -#import platform -#if platform.python_version() < '2.4': -# from sets import Set as set -#from sys import version_info -#ver = '%s.%s' % version_info[0:2] -# end osx-patch - -import subprocess -import os -if os.name != 'mac': - try: - import psyco - psyco.log(Blender.Get('tempdir')+"/blender.log-psyco") - #psyco.log() - psyco.full(memory=100) - psyco.profile(0.05, memory=100) - psyco.profile(0.2) - #print 'psyco imported' - except ImportError: - print 'psyco not imported' - -print '\n\n\n' -print 'DXF/DWG-Importer v%s *** start ***' %(__version__) #--------------------- - -SCENE = None -WORLDX = Mathutils.Vector((1,0,0)) -WORLDY = Mathutils.Vector((0,1,0)) -WORLDZ = Mathutils.Vector((0,0,1)) - -G_SCALE = 1.0 #(0.0001-1000) global scaling factor for all dxf data -G_ORIGIN_X = 0.0 #global translation-vector (x,y,z) in DXF units -G_ORIGIN_Y = 0.0 -G_ORIGIN_Z = 0.0 -MIN_DIST = 0.001 #cut-off value for sort out short-distance polyline-"duoble_vertex" -ARC_RESOLUTION = 64 #(4-500) arc/circle resolution - number of segments -ARC_RADIUS = 1.0 #(0.01-100) arc/circle radius for number of segments algorithm -CURV_RESOLUTION = 12 #(1-128) Bezier curves U-resolution -CURVARC_RESOLUTION = 4 #(3-32) resolution of circle represented as Bezier curve -THIN_RESOLUTION = 8 #(4-64) thin_cylinder arc_resolution - number of segments -MIN_THICK = MIN_DIST * 10.0 #minimal thickness by forced thickness -MIN_WIDTH = MIN_DIST * 10.0 #minimal width by forced width -TRIM_LIMIT = 3.0 #limit for triming of polylines-wide-segments (values:0.0 - 5.0) -ELEVATION = 0.0 #standard elevation = coordinate Z value - -BYBLOCK = 0 -BYLAYER = 256 -TARGET_LAYER = 3 #target blender_layer -GROUP_BYLAYER = 0 #(0/1) all entities from same layer import into one blender-group -LAYER_DEF_NAME = 'AAAA' #default layer name -LAYER_DEF_COLOR = 4 #default layer color -E_M = 0 -LAB = ". wip .. todo" #"*) parts under construction" -M_OBJ = 0 - -FILENAME_MAX = 180 #max length of path+file_name string (FILE_MAXDIR + FILE_MAXFILE) -MAX_NAMELENGTH = 17 #max_effective_obnamelength in blender =21=17+(.001) -INIFILE_DEFAULT_NAME = 'importDXF' -INIFILE_EXTENSION = '.ini' -INIFILE_HEADER = '#ImportDXF.py ver.1.0 config data' -INFFILE_HEADER = '#ImportDXF.py ver.1.0 analyze of DXF-data' - -AUTO = BezTriple.HandleTypes.AUTO -FREE = BezTriple.HandleTypes.FREE -VECT = BezTriple.HandleTypes.VECT -ALIGN = BezTriple.HandleTypes.ALIGN - -UI_MODE = True #activates UI-popup-print, if not multiple files imported - -#---- 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 - - -#-------- 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-Importer cant find external DWG-converter (%s) in 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 = 'The external DWG-converter (%s) needs Wine installed on your system.|\ -More details in online Help.' %extCONV -#print 'extCONV_PATH = ', extCONV_PATH - - - -class View: #----------------------------------------------------------------- - """Class for objects representing dxf VIEWs. - """ - def __init__(self, obj, active=None): - """Expects an object of type VIEW as input. - """ - if not obj.type == 'view': - raise TypeError, "Wrong type %s for VIEW object!" %obj.type - - self.type = obj.type - self.name = obj.get_type(2)[0] -# self.data = obj.data[:] - - - self.centerX = getit(obj, 10, 0.0) #view center pointX (in DCS) - self.centerY = getit(obj, 20, 0.0) #view center pointY (in DCS) - self.height = obj.get_type(40)[0] #view height (in DCS) - self.width = obj.get_type(41)[0] #view width (in DCS) - - self.dir = [0,0,0] - self.dir[0] = getit(obj, 11, 0.0) #view directionX from target (in WCS) - self.dir[1] = getit(obj, 21, 0.0) # - self.dir[2] = getit(obj, 31, 0.0) # - - self.target = [0,0,0] - self.target[0] = getit(obj, 12, 0.0) #target pointX(in WCS) - self.target[1] = getit(obj, 22, 0.0) # - self.target[2] = getit(obj, 32, 0.0) # - - self.length = obj.get_type(42)[0] #Lens length - self.clip_front = getit(obj, 43) #Front clipping plane (offset from target point) - self.clip_back = getit(obj, 44) #Back clipping plane (offset from target point) - self.twist = obj.get_type(50)[0] #view twist angle in degrees - - self.flags = getit(obj, 70, 0) - self.paperspace = self.flags & 1 # - - self.mode = obj.get_type(71)[0] #view mode (VIEWMODE system variable) - - def __repr__(self): - return "%s: name - %s, focus length - %s" %(self.__class__.__name__, self.name, self.length) - - - def draw(self, settings): - """for VIEW: generate Blender_camera. - """ - obname = 'vw_%s' %self.name # create camera object name - #obname = 'ca_%s' %self.name # create camera object name - obname = obname[:MAX_NAMELENGTH] - - if self.target == [0,0,0] and Mathutils.Vector(self.dir).length == 1.0: - cam= Camera.New('ortho', obname) - ob= SCENE.objects.new(cam) - cam.type = 'ortho' - cam.scale = 1.0 # for ortho cameras - else: - cam= Camera.New('persp', obname) - ob= SCENE.objects.new(cam) - cam.type = 'persp' - cam.angle = 60.0 # for persp cameras - if self.length: - #cam.angle = 2 * atan(17.5/self.length) * 180/pi - cam.lens = self.length #for persp cameras - # hack to update Camera>Lens setting (inaccurate as a focal length) - #curLens = cam.lens; cam.lens = curLens - # AutoCAD gets clip distance from target: - dist = Mathutils.Vector(self.dir).length - cam.clipEnd = dist - self.clip_back - cam.clipStart = dist - self.clip_front - - cam.drawLimits = 1 - cam.drawSize = 10 - - v = Mathutils.Vector(self.dir) -# print 'deb:view cam:', cam #------------ -# print 'deb:view self.target:', self.target #------------ -# print 'deb:view self.dir:', self.dir #------------ -# print 'deb:view self.twist:', self.twist #------------ -# print 'deb:view self.clip_front=%s, self.clip_back=%s, dist=%s' %(self.clip_front, self.clip_back, dist) #------------ - transform(v.normalize(), -self.twist, ob) - ob.loc = Mathutils.Vector(self.target) + Mathutils.Vector(self.dir) - return ob - - -class Vport: #----------------------------------------------------------------- - """Class for objects representing dxf VPORTs. - """ - def __init__(self, obj, active=None): - """Expects an object of type VPORT as input. - """ - if not obj.type == 'vport': - raise TypeError, "Wrong type %s for VPORT object!" %obj.type - - self.type = obj.type - self.name = obj.get_type(2)[0] -# self.data = obj.data[:] - #print 'deb:vport name, data:', self.name #------- - #print 'deb:vport data:', self.data #------- - - self.height = obj.get_type(40)[0] #vport height (in DCS) - self.centerX = getit(obj, 12, 0.0) #vport center pointX (in DCS) - self.centerY = getit(obj, 22, 0.0) #vport center pointY (in DCS) - self.width = self.height * obj.get_type(41)[0] #vport aspect ratio - width (in DCS) - - self.dir = [0,0,0] - self.dir[0] = getit(obj, 16, 0.0) #vport directionX from target (in WCS) - self.dir[1] = getit(obj, 26, 0.0) # - self.dir[2] = getit(obj, 36, 0.0) # - - self.target = [0,0,0] - self.target[0] = getit(obj, 17, 0.0) #target pointX(in WCS) - self.target[1] = getit(obj, 27, 0.0) # - self.target[2] = getit(obj, 37, 0.0) # - - self.length = obj.get_type(42)[0] #Lens length - self.clip_front = getit(obj, 43) #Front clipping plane (offset from target point) - self.clip_back = getit(obj, 44) #Back clipping plane (offset from target point) - self.twist = obj.get_type(51)[0] #view twist angle - - self.flags = getit(obj, 70, 0) - self.paperspace = self.flags & 1 # - - self.mode = obj.get_type(71)[0] #view mode (VIEWMODE system variable) - - def __repr__(self): - return "%s: name - %s, focus length - %s" %(self.__class__.__name__, self.name, self.length) - - def draw(self, settings): - """for VPORT: generate Blender_camera. - """ - obname = 'vp_%s' %self.name # create camera object name - #obname = 'ca_%s' %self.name # create camera object name - obname = obname[:MAX_NAMELENGTH] - - if self.target == [0,0,0] and Mathutils.Vector(self.dir).length == 1.0: - cam= Camera.New('ortho', obname) - ob= SCENE.objects.new(cam) - cam.type = 'ortho' - cam.scale = 1.0 # for ortho cameras - else: - cam= Camera.New('persp', obname) - ob= SCENE.objects.new(cam) - cam.type = 'persp' - cam.angle = 60.0 # for persp cameras - if self.length: - #cam.angle = 2 * atan(17.5/self.length) * 180/pi - cam.lens = self.length #for persp cameras - # hack to update Camera>Lens setting (inaccurate as a focal length) - #curLens = cam.lens; cam.lens = curLens - # AutoCAD gets clip distance from target: - dist = Mathutils.Vector(self.dir).length - cam.clipEnd = dist - self.clip_back - cam.clipStart = dist - self.clip_front - - cam.drawLimits = 1 - cam.drawSize = 10 - - v = Mathutils.Vector(self.dir) -# print 'deb:view cam:', cam #------------ -# print 'deb:view self.target:', self.target #------------ -# print 'deb:view self.dir:', self.dir #------------ -# print 'deb:view self.twist:', self.twist #------------ -# print 'deb:view self.clip_front=%s, self.clip_back=%s, dist=%s' %(self.clip_front, self.clip_back, dist) #------------ - transform(v.normalize(), -self.twist, ob) - ob.loc = Mathutils.Vector(self.target) + Mathutils.Vector(self.dir) - return ob - - - -class Layer: #----------------------------------------------------------------- - """Class for objects representing dxf LAYERs. - """ - def __init__(self, obj, name=None, color=None, frozen=None): - """Expects an dxfobject of type layer as input. - if no dxfobject - creates surogate layer with default parameters - """ - - if obj==None: - self.type = 'layer' - if name: self.name = name - else: self.name = LAYER_DEF_NAME - - if color: self.color = color - else: self.color = LAYER_DEF_COLOR - - if frozen!=None: self.frozen = frozen - else: self.frozen = 0 - else: - if obj.type=='layer': - self.type = obj.type - #self.data = obj.data[:] - if name: self.name = name - #self.bfname = name #--todo---see layernamesmap in f_getLayersmap --- - else: self.name = obj.get_type(2)[0] #layer name of object - - if color: self.color = color - else: self.color = obj.get_type(62)[0] #color of object - - if frozen!=None: self.frozen = frozen - else: - self.flags = obj.get_type(70)[0] - self.frozen = self.flags & 1 - - def __repr__(self): - return "%s: name - %s, color - %s" %(self.__class__.__name__, self.name, self.color) - - - -def getit(obj, typ, default=None): #------------------------------------------ - """Universal procedure for geting data from list/objects. - """ - it = default - if type(obj) == list: #if obj is a list, then searching in a list - for item in obj: - #print 'deb:getit item, type(item)', item, type(item) - try: - if item[0] == typ: - it = item[1] - break #as soon as the first found - except: - # --todo-- I found one case where item was a text instance - # that failed with no __getitem__ - pass - else: #else searching in Object with get_type-Methode - item = obj.get_type(typ) - if item: - it = item[0] - #print 'deb:getit:typ, it', typ, it #---------- - return it - - - -def get_extrusion(data): #------------------------------------------------- - """Find the axis of extrusion. - - Used to get from object_data the objects Object_Coordinate_System (ocs). - """ - #print 'deb:get_extrusion: data: \n', data #--------------- - vec = [0,0,1] - vec[0] = getit(data, 210, 0) # 210 = x - vec[1] = getit(data, 220, 0) # 220 = y - vec[2] = getit(data, 230, 1) # 230 = z - #print 'deb:get_extrusion: vec: ', vec #--------------- - return vec - - -#------------------------------------------ -def getSceneChild(name): - dudu = [i for i in SCENE.objects if i.name==name] -# dudu = [i for i in SCENE.getChildren() if i.name==name] - #print 'deb:getSceneChild %s -result: %s:' %(name,dudu) #----------------- - if dudu!=[]: return dudu[0] - return None - - -class Solid: #----------------------------------------------------------------- - """Class for objects representing dxf SOLID or TRACE. - """ - def __init__(self, obj): - """Expects an entity object of type solid or trace as input. - """ - if obj.type == 'trace': - obj.type = 'solid' - if not obj.type == 'solid': - raise TypeError, "Wrong type \'%s\' for solid/trace object!" %obj.type - - self.type = obj.type -# self.data = obj.data[:] - - self.space = getit(obj, 67, 0) - self.thic = getit(obj, 39, 0) - self.color_index = getit(obj, 62, BYLAYER) - - self.layer = getit(obj, 8, None) - self.extrusion = get_extrusion(obj) - self.points = self.get_points(obj) - - - - def get_points(self, data): - """Gets start and end points for a solid type object. - - Solids have 3 or 4 points and fixed codes for each value. - """ - - # start x, y, z and end x, y, z = 0 - a = [0, 0, 0] - b = [0, 0, 0] - c = [0, 0, 0] - d = [0, 0, 0] - a[0] = getit(data, 10, None) # 10 = x - a[1] = getit(data, 20, None) # 20 = y - a[2] = getit(data, 30, 0) # 30 = z - b[0] = getit(data, 11, None) - b[1] = getit(data, 21, None) - b[2] = getit(data, 31, 0) - c[0] = getit(data, 12, None) - c[1] = getit(data, 22, None) - c[2] = getit(data, 32, 0) - out = [a,b,c] - - d[0] = getit(data, 13, None) - if d[0] != None: - d[1] = getit(data, 23, None) - d[2] = getit(data, 33, 0) - out.append(d) - #print 'deb:solid.vertices:---------\n', out #----------------------- - return out - - - def __repr__(self): - return "%s: layer - %s, points - %s" %(self.__class__.__name__, self.layer, self.points) - - - def draw(self, settings): - """for SOLID: generate Blender_geometry. - """ - points = self.points - if not points: return - edges, faces = [], [] - l = len(self.points) - - obname = 'so_%s' %self.layer # create object name from layer name - obname = obname[:MAX_NAMELENGTH] - - vg_left, vg_right, vg_top, vg_bottom, vg_start, vg_end = [], [], [], [], [], [] - thic = set_thick(self.thic, settings) - if thic != 0: - thic_points = [[v[0], v[1], v[2] + thic] for v in points[:]] - if thic < 0.0: - thic_points.extend(points) - points = thic_points - else: - points.extend(thic_points) - - if l == 4: - faces = [[0,1,3,2], [4,6,7,5], [0,4,5,1], - [1,5,7,3], [3,7,6,2], [2,6,4,0]] - vg_left = [2,6,4,0] - vg_right = [1,5,7,3] - vg_top = [4,6,7,5] - vg_bottom = [0,1,3,2] - vg_start = [0,4,5,1] - vg_end = [3,7,6,2] - elif l == 3: - faces = [[0,1,2], [3,5,4], [0,3,4,1], [1,4,5,2], [2,5,3,0]] - vg_top = [3,4,5] - vg_bottom = [0,1,2] - vg_left = [2,5,3,0] - vg_right = [1,4,5,2] - vg_start = [0,3,4,1] - elif l == 2: faces = [[0,1,3,2]] - else: - if l == 4: faces = [[0,1,3,2]] - elif l == 3: faces = [[0,1,2]] - elif l == 2: edges = [[0,1]] - - if M_OBJ: obname, me, ob = makeNewObject() - else: - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - me.verts.extend(points) # add vertices to mesh - if faces: me.faces.extend(faces) # add faces to the mesh - if edges: me.edges.extend(edges) # add faces to the mesh - - if settings.var['vGroup_on'] and not M_OBJ: - # each MeshSide becomes vertexGroup for easier material assignment --------------------- - replace = Mesh.AssignModes.ADD #or .AssignModes.ADD/REPLACE - if vg_left: me.addVertGroup('side.left') ; me.assignVertsToGroup('side.left', vg_left, 1.0, replace) - if vg_right:me.addVertGroup('side.right') ; me.assignVertsToGroup('side.right', vg_right, 1.0, replace) - if vg_top: me.addVertGroup('side.top') ; me.assignVertsToGroup('side.top', vg_top, 1.0, replace) - if vg_bottom:me.addVertGroup('side.bottom'); me.assignVertsToGroup('side.bottom',vg_bottom, 1.0, replace) - if vg_start:me.addVertGroup('side.start') ; me.assignVertsToGroup('side.start', vg_start, 1.0, replace) - if vg_end: me.addVertGroup('side.end') ; me.assignVertsToGroup('side.end', vg_end, 1.0, replace) - - transform(self.extrusion, 0, ob) - - return ob - -class Line: #----------------------------------------------------------------- - """Class for objects representing dxf LINEs. - """ - def __init__(self, obj): - """Expects an entity object of type line as input. - """ - if not obj.type == 'line': - raise TypeError, "Wrong type \'%s\' for line object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - - self.space = getit(obj, 67, 0) - self.thic = getit(obj, 39, 0) - #print 'deb:self.thic: ', self.thic #--------------------- - self.color_index = getit(obj, 62, BYLAYER) - - self.layer = getit(obj, 8, None) - self.extrusion = get_extrusion(obj) - self.points = self.get_points(obj) - - - def get_points(self, data): - """Gets start and end points for a line type object. - - Lines have a fixed number of points (two) and fixed codes for each value. - """ - # start x,y,z and end x,y,z = 0 - a = [0, 0, 0] - b = [0, 0, 0] - a[0] = getit(data, 10, None) # 10 = x - a[1] = getit(data, 20, None) # 20 = y - a[2] = getit(data, 30, 0) # 30 = z - b[0] = getit(data, 11, None) - b[1] = getit(data, 21, None) - b[2] = getit(data, 31, 0) - out = [a,b] - return out - - - def __repr__(self): - return "%s: layer - %s, points - %s" %(self.__class__.__name__, self.layer, self.points) - - - def draw(self, settings): - """for LINE: generate Blender_geometry. - """ - # Generate the geometery - #settings.var['curves_on']=False - - points = self.points - thic = set_thick(self.thic, settings) - width = 0.0 - if settings.var['lines_as'] == 4: # as thin_box - thic = settings.var['thick_min'] - width = settings.var['width_min'] - elif settings.var['lines_as'] == 3: # as thin cylinder - cyl_rad = 0.5 * settings.var['width_min'] - - elif settings.var['lines_as'] == 5: # LINE curve representation------------------------- - obname = 'li_%s' %self.layer # create object name from layer name - obname = obname[:MAX_NAMELENGTH] - - c = Curve.New(obname) # create new curve data - curve = c.appendNurb(BezTriple.New(points[0])) - curve.append(BezTriple.New(points[1])) - for point in curve: - point.handleTypes = [VECT, VECT] - point.radius = 1.0 - curve.flagU = 0 # 0 sets the curve not cyclic=open - c.setResolu(settings.var['curve_res']) - c.update() #important for handles calculation - - ob = SCENE.objects.new(c) # create a new curve_object - - #if False: # --todo-- better support for 210-group - if thic != 0.0: #hack: Blender2.45 curve-extrusion - t = thic * 0.5 - if abs(t) > 5.0: t = 5.0 * cmp(t,0) # Blender2.45 accepts only (0.0 - 5.0) - e = self.extrusion - c.setExt1(abs(t)) # curve-extrusion - ob.LocX += t * e[0] - ob.LocY += t * e[1] - ob.LocZ += t * e[2] - #c.setExt1(1.0) # curve-extrusion: Blender2.45 accepts only (0.0 - 5.0) - #ob.LocZ = t + self.loc[2] - #ob.SizeZ *= abs(t) - return ob - - else: # LINE mesh representation ------------------------------ - global activObjectLayer - global activObjectName - #print 'deb:draw:line.ob IN activObjectName: ', activObjectName #--------------------- - - if M_OBJ: obname, me, ob = makeNewObject() - else: - if activObjectLayer == self.layer and settings.var['one_mesh_on']: - obname = activObjectName - #print 'deb:line.draw obname from activObjectName: ', obname #--------------------- - ob = getSceneChild(obname) # open an existing mesh_object - #ob = SCENE.getChildren(obname) # open an existing mesh_object - #me = Mesh.Get(ob.name) # open objects mesh data - me = ob.getData(name_only=False, mesh=True) - else: - obname = 'li_%s' %self.layer # create object name from layer name - obname = obname[:MAX_NAMELENGTH] - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - activObjectName = ob.name - activObjectLayer = self.layer - #print ('deb:line.draw new line.ob+mesh:"%s" created!' %ob.name) #--------------------- - - faces, edges = [], [] - n = len(me.verts) - - #if settings.var['width_force']: #--todo----------- - - if thic != 0: - t, e = thic, self.extrusion - #print 'deb:thic, extr: ', t, e #--------------------- - points.extend([[v[0]+t*e[0], v[1]+t*e[1], v[2]+t*e[2]] for v in points[:]]) - faces = [[0+n, 1+n, 3+n, 2+n]] - else: - edges = [[0+n, 1+n]] - - me.verts.extend(points) # adds vertices to global mesh - if faces: me.faces.extend(faces) # add faces to the mesh - if edges: me.edges.extend(edges) # add faces to the mesh - - if settings.var['vGroup_on'] and not M_OBJ: - # entities with the same color build one vertexGroup for easier material assignment ---- - ob.link(me) # link mesh to that object - vG_name = 'color_%s' %self.color_index - if edges: faces = edges - replace = Mesh.AssignModes.ADD #or .AssignModes.REPLACE or ADD - try: - me.assignVertsToGroup(vG_name, faces[0], 1.0, replace) - #print 'deb: existed vGroup:', vG_name #--------------------- - except: - me.addVertGroup(vG_name) - me.assignVertsToGroup(vG_name, faces[0], 1.0, replace) - #print 'deb: create new vGroup:', vG_name #--------------------- - - - #print 'deb:draw:line.ob OUT activObjectName: ', activObjectName #--------------------- - return ob - - - -class Point: #----------------------------------------------------------------- - """Class for objects representing dxf POINTs. - """ - def __init__(self, obj): - """Expects an entity object of type point as input. - """ - if not obj.type == 'point': - raise TypeError, "Wrong type %s for point object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - - self.space = getit(obj, 67, 0) - self.thic = getit(obj, 39, 0) - #print 'deb:self.thic: ', self.thic #--------------------- - self.color_index = getit(obj, 62, BYLAYER) - - self.layer = getit(obj, 8, None) - self.extrusion = get_extrusion(obj) - self.points = self.get_points(obj) - - - def get_points(self, data): - """Gets coordinates for a point type object. - - Points have fixed codes for each value. - """ - a = [0, 0, 0] - a[0] = getit(data, 10, None) # 10 = x - a[1] = getit(data, 20, None) # 20 = y - a[2] = getit(data, 30, 0) # 30 = z - out = [a] - return out - - - def __repr__(self): - return "%s: layer - %s, points - %s" %(self.__class__.__name__, self.layer, self.points) - - - def draw(self, settings): - """for POINT: generate Blender_geometry. - """ - points = self.points - obname = 'po_%s' %self.layer # create object name from layer name - obname = obname[:MAX_NAMELENGTH] - points_as = settings.var['points_as'] - thic = settings.var['thick_min'] - if thic < settings.var['dist_min']: thic = settings.var['dist_min'] - - if points_as in [1,3,4,5]: - if points_as in [1,5]: # as 'empty' - c = 'Empty' - elif points_as == 3: # as 'thin sphere' - res = settings.var['thin_res'] - c = Mesh.Primitives.UVsphere(res,res,thic) - elif points_as == 4: # as 'thin box' - c = Mesh.Primitives.Cube(thic) - ob = SCENE.objects.new(c, obname) # create a new object - transform(self.extrusion, 0, ob) - ob.loc = tuple(points[0]) - - elif points_as == 2: # as 'vertex' - global activObjectLayer - global activObjectName - #print 'deb:draw:point.ob IN activObjectName: ', activObjectName #--------------------- - if M_OBJ: obname, me, ob = makeNewObject() - else: - if activObjectLayer == self.layer and settings.var['one_mesh_on']: - obname = activObjectName - #print 'deb:draw:point.ob obname from activObjectName: ', obname #--------------------- - ob = getSceneChild(obname) # open an existing mesh_object - #ob = SCENE.getChildren(obname) # open an existing mesh_object - me = ob.getData(name_only=False, mesh=True) - #me = Mesh.Get(ob.name) # open objects mesh data - else: - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - activObjectName = ob.name - activObjectLayer = self.layer - #print ('deb:draw:point new point.ob+mesh:"%s" created!' %ob.name) #--------------------- - me.verts.extend(points) # add vertices to mesh - - return ob - - - -class Polyline: #----------------------------------------------------------------- - """Class for objects representing dxf POLYLINEs. - """ - def __init__(self, obj): - """Expects an entity object of type polyline as input. - """ - #print 'deb:polyline.init.START:----------------' #------------------------ - if not obj.type == 'polyline': - raise TypeError, "Wrong type %s for polyline object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - - self.space = getit(obj, 67, 0) - self.elevation = getit(obj, 30, 0) - #print 'deb:elevation: ', self.elevation #--------------- - self.thic = getit(obj, 39, 0) - self.color_index = getit(obj, 62, BYLAYER) - - self.flags = getit(obj, 70, 0) - self.closed = self.flags & 1 # closed in the M direction - self.curved = self.flags & 2 # Bezier-curve-fit vertices have been added - self.spline = self.flags & 4 # NURBS-curve-fit vertices have been added - self.poly3d = self.flags & 8 # 3D-polyline - self.plmesh = self.flags & 16 # 3D-polygon mesh - self.closeN = self.flags & 32 # closed in the N direction - self.plface = self.flags & 64 # 3D-polyface mesh - self.contin = self.flags & 128 # the linetype pattern is generated continuously - - self.pltype='poly2d' # default is a 2D-polyline - if self.poly3d: self.pltype='poly3d' - elif self.plface: self.pltype='plface' - elif self.plmesh: self.pltype='plmesh' - - self.swidth = getit(obj, 40, 0) # default start width - self.ewidth = getit(obj, 41, 0) # default end width - #self.bulge = getit(obj, 42, None) # bulge of the segment - self.vectorsM = getit(obj, 71, None) # PolyMesh: expansion in M-direction / PolyFace: number of the vertices - self.vectorsN = getit(obj, 72, None) # PolyMesh: expansion in M-direction / PolyFace: number of faces - #self.resolM = getit(obj, 73, None) # resolution of surface in M direction - #self.resolN = getit(obj, 74, None) # resolution of surface in N direction - self.curvNoFitted = False - self.curvQuadrati = False - self.curvCubicBsp = False - self.curvBezier = False - curvetype = getit(obj, 75, 0) # type of curve/surface: 0=None/5=Quadric/6=Cubic/8=Bezier - if curvetype == 0: self.curvNoFitted = True - elif curvetype == 5: self.curvQuadrati = True - elif curvetype == 6: self.curvCubicBsp = True - elif curvetype == 8: self.curvBezier = True - - self.layer = getit(obj, 8, None) - self.extrusion = get_extrusion(obj) - - self.points = [] #list with vertices coordinats - self.faces = [] #list with vertices assigment to faces - #print 'deb:polyline.init.ENDinit:----------------' #------------ - - - - def __repr__(self): - return "%s: layer - %s, points - %s" %(self.__class__.__name__, self.layer, self.points) - - - - def doubles_out(self, settings, d_points): - """routine to sort out of double.vertices----------------------------- - """ - minimal_dist = settings.var['dist_min'] * 0.1 - dv_count = 0 - temp_points = [] - for i in xrange(len(d_points)-1): - point = d_points[i] - point2 = d_points[i+1] - #print 'deb:double.vertex p1,p2', point, point2 #------------------------ - delta = Mathutils.Vector(point2.loc) - Mathutils.Vector(point.loc) - if delta.length > minimal_dist: - temp_points.append(point) - else: - dv_count+=1 - #print 'deb:drawPoly2d double.vertex sort out! count=', dv_count #------------------------ - temp_points.append(d_points[-1]) #------ incl. last vertex ------------- - #if self.closed: temp_points.append(d_points[1]) #------ loop start vertex ------------- - d_points = temp_points #-----vertex.list without "double.vertices" - #print 'deb:drawPoly2d d_pointsList =after DV-outsorting=====:\n ', d_points #------------------------ - return d_points - - - def tribles_out(self, settings, d_points): - """routine to sort out of three_in_place.vertices----------------------------- - """ - minimal_dist = settings.var['dist_min'] * 0.1 - dv_count = 0 - temp_points = [] - for i in xrange(len(d_points)-2): - point1 = d_points[i] - point2 = d_points[i+1] - point3 = d_points[i+2] - #print 'deb:double.vertex p1,p2', point, point2 #------------------------ - delta12 = Mathutils.Vector(point2.loc) - Mathutils.Vector(point1.loc) - delta23 = Mathutils.Vector(point3.loc) - Mathutils.Vector(point2.loc) - if delta12.length < minimal_dist and delta23.length < minimal_dist: - dv_count+=1 - else: - temp_points.append(point1) - #print 'deb:drawPoly2d double.vertex sort out! count=', dv_count #------------------------ - point1 = d_points[-2] - point2 = d_points[-1] - delta12 = Mathutils.Vector(point2.loc) - Mathutils.Vector(point1.loc) - if delta12.length > minimal_dist: - temp_points.append(d_points[-2]) #------ incl. 2last vertex ------------- - temp_points.append(d_points[-1]) #------ incl. 1last vertex ------------- - #if self.closed: temp_points.append(d_points[1]) #------ loop start vertex ------------- - d_points = temp_points #-----vertex.list without "double.vertices" - #print 'deb:drawPoly2d d_pointsList =after DV-outsorting=====:\n ', d_points #------------------------ - return d_points - - - def draw(self, settings): #-------------%%%% DRAW POLYLINE %%%--------------- - """for POLYLINE: generate Blender_geometry. - """ - #print 'deb:drawPOLYLINE.START:----------------' #------------------------ - #print 'deb:POLYLINEdraw self.pltype:', self.pltype #------------------------ - #print 'deb:POLYLINEdraw self.points:\n', self.points #------------------------ - ob = [] - #---- 3dPolyFace - mesh with free topology - if self.pltype=='plface' and settings.drawTypes['plmesh']: - ob = self.drawPlFace(settings) - #---- 3dPolyMesh - mesh with ortogonal topology - elif self.pltype=='plmesh' and settings.drawTypes['plmesh']: - ob = self.drawPlMesh(settings) - - #---- 2dPolyline - plane polyline with arc/wide/thic segments - elif self.pltype=='poly2d' and settings.drawTypes['polyline']: - if settings.var['plines_as'] in [5,6]: # and self.spline: - ob = self.drawPolyCurve(settings) - else: - ob = self.drawPoly2d(settings) - - #---- 3dPolyline - non-plane polyline (thin segments = without arc/wide/thic) - elif self.pltype=='poly3d' and settings.drawTypes['pline3']: - if settings.var['plines3_as'] in [5,6]: # and self.spline: - ob = self.drawPolyCurve(settings) - else: - ob = self.drawPoly2d(settings) - - #---- Spline - curved polyline (thin segments = without arc/wide/thic) - elif self.pltype=='spline' and settings.drawTypes['spline']: - if settings.var['splines_as'] in [5,6]: - ob = self.drawPolyCurve(settings) - else: - ob = self.drawPoly2d(settings) - return ob - - - def drawPlFace(self, settings): #---- 3dPolyFace - mesh with free topology - """Generate the geometery of polyface. - """ - #print 'deb:drawPlFace.START:----------------' #------------------------ - points = [] - faces = [] - #print 'deb:len of pointsList ====== ', len(self.points) #------------------------ - for point in self.points: - if point.face: - faces.append(point.face) - else: - points.append(point.loc) - - if settings.var['plmesh_flip']: # ---------------------- - for face in faces: - face.reverse() - face = [face[-1]] + face[:-1] - - #print 'deb:drawPlFace: len of points_list:\n', len(points) #----------------------- - #print 'deb:drawPlFace: len of faces_list:\n', len(faces) #----------------------- - #print 'deb:drawPlFace: points_list:\n', points #----------------------- - #print 'deb:drawPlFace: faces_list:\n', faces #----------------------- - obname = 'pf_%s' %self.layer # create object name from layer name - obname = obname[:MAX_NAMELENGTH] - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - me.verts.extend(points) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - if settings.var['normals_out']: # ---------------------- - #me.flipNormals() - me.recalcNormals(0) - #me.update() - #print 'deb:drawPlFace: len of me.faces:\n', len(me.faces) #----------------------- - - if settings.var['meshSmooth_on']: # ---------------------- - for i in xrange(len(me.faces)): - me.faces[i].smooth = True - #me.Mode(AUTOSMOOTH) - transform(self.extrusion, 0, ob) - #print 'deb:drawPlFace.END:----------------' #------------------------ - return ob - - - - def drawPlMesh(self, settings): #---- 3dPolyMesh - mesh with orthogonal topology - """Generate the geometery of polymesh. - """ - #print 'deb:polymesh.draw.START:----------------' #------------------------ - #points = [] - #print 'deb:len of pointsList ====== ', len(self.points) #------------------------ - faces = [] - m = self.vectorsM - n = self.vectorsN - for j in xrange(m - 1): - for i in xrange(n - 1): - nn = j * n - faces.append([nn+i, nn+i+1, nn+n+i+1, nn+n+i]) - - if self.closed: #mesh closed in N-direction - nn = (m-1)*n - for i in xrange(n - 1): - faces.append([nn+i, nn+i+1, i+1, i]) - - if self.closeN: #mesh closed in M-direction - for j in xrange(m-1): - nn = j * n - faces.append([nn+n-1, nn, nn+n, nn+n-1+n]) - - if self.closed and self.closeN: #mesh closed in M/N-direction - faces.append([ (n*m)-1, (m-1)*n, 0, n-1]) - - #print 'deb:len of points_list:\n', len(points) #----------------------- - #print 'deb:faces_list:\n', faces #----------------------- - obname = 'pm_%s' %self.layer # create object name from layer name - obname = obname[:MAX_NAMELENGTH] - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - me.verts.extend([point.loc for point in self.points]) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - if settings.var['normals_out']: # ---------------------- - #me.flipNormals() - me.recalcNormals(0) - #me.update() - if settings.var['meshSmooth_on']: # ---------------------- - for i in xrange(len(faces)): - me.faces[i].smooth = True - #me.Mode(AUTOSMOOTH) - - transform(self.extrusion, 0, ob) - #print 'deb:polymesh.draw.END:----------------' #------------------------ - return ob - - - def drawPolyCurve(self, settings): #---- Polyline - draw as Blender-curve - """Generate the geometery of polyline as Blender-curve. - """ - #print 'deb:polyline2dCurve.draw.START:----------------' #--- - if len(self.points) < 2: - #print 'deb:drawPoly2d exit, cause POLYLINE has less than 2 vertices' #--------- - return - - if self.spline: pline_typ = 'ps' # Polyline-NURBSpline - elif self.curved: pline_typ = 'pc' # Polyline-BezierCurve - else: pline_typ = 'pl' # Polyline classic - obname = '%s_%s' %(pline_typ, self.layer) # create object_name from layer name - obname = obname[:MAX_NAMELENGTH] - d_points = [] - - if settings.var['Z_force_on']: - self.elevation = settings.var['Z_elev'] - for point in self.points: - point.loc[2] = self.elevation - d_points.append(point) - else: #for DXFr10-format: update all points[].loc[2] == None -> 0.0 - for point in self.points: - if point.loc[2] == None: - point.loc[2] = self.elevation - d_points.append(point) - - #d_points = self.tribles_out(settings, d_points) - #d_points = self.doubles_out(settings, d_points) - #print 'deb:drawPolyCurve d_pointsList =after DV-outsorting=====:\n ', d_points #------------------------ - - thic = set_thick(self.thic, settings) - if thic != 0.0: #hack: Blender<2.45 curve-extrusion - LocZ = d_points[0].loc[2] - temp_points = [] - for point in d_points: - point.loc[2] = 0.0 - temp_points.append(point) - d_points = temp_points - - #print 'deb:polyline2dCurve.draw d_points=', d_points #--------------- - pline = Curve.New(obname) # create new curve data - #pline.setResolu(24) #--todo----- - - if self.spline: # NURBSplines-----OK----- - #print 'deb:polyline2dCurve.draw self.spline!' #--------------- - nurbs_points = [] - for d in d_points: - pkt = d.loc - pkt.append(d.weight) - nurbs_points.append(pkt) - firstpoint = nurbs_points[0] - curve = pline.appendNurb(firstpoint) - curve.setType(4) # set curve_type NURBS - print 'deb: dir(curve):', dir(curve[-1]) #---------------- - for point in nurbs_points[1:]: - curve.append(point) - #TODO: what is the trick for bevel radius? curve[-1].radius = 1.0 - if self.closed: - curve.flagU = 1+0 # Set curve cyclic=close and uni - else: - curve.flagU = 0+2 # Set curve not cyclic=open - try: curve.orderU = 5 # works only with >2.46svn080625 - except AttributeError: pass - #print 'deb: dir(curve):', dir(curve) #---------------- - - elif self.curved: #--SPLINE as Bezier-curves---wip------ - #print 'deb:polyline2dCurve.draw self.curved!' #--------------- - begtangent, endtangent = None, None - if d_points[0].tangent: - begtangent = d_points[0] - d_points = d_points[1:] - if d_points[-1].tangent: - endtangent = d_points[-1] - d_points = d_points[:-1] - curve = pline.appendNurb(BezTriple.New(d_points[0])) - for p in d_points[1:]: - curve.append(BezTriple.New(p)) - for point in curve: - point.handleTypes = [AUTO, AUTO] - point.radius = 1.0 - #curve.setType(1) #Bezier curve - if self.closed: - curve.flagU = 5 #1 # Set curve cyclic=close - else: - curve.flagU = 4 #0 # Set curve not cyclic=open - if begtangent: - #print 'deb:polyline2dCurve.draw curve[0].vec:', curve[0].vec #----- - #print 'deb:polyline2dCurve.draw begtangent:', begtangent #----- - p0h1,p0,p0h2 = curve[0].vec - p0h1 = [p0h1[i]+begtangent[i] for i in range(3)] - curve.__setitem__(0,BezTriple.New(p0h1+p0+p0h2)) - curve[0].handleTypes = [FREE, ALIGN] #remi--todo----- - curve[0].radius = 1.0 - if endtangent: - #print 'deb:polyline2dCurve.draw curve[-1].vec:', curve[-1].vec #----- - #print 'deb:polyline2dCurve.draw endtangent:', endtangent #----- - p0h1,p0,p0h2 = curve[-1].vec - p0h2 = [p0h2[i]+endtangent[i] for i in range(3)] - #print 'deb:drawPlineCurve: p0h2:', p0h2 #---------- - curve.__setitem__(-1,BezTriple.New(p0h1+p0+p0h2)) - #print 'deb:polyline2dCurve.draw curve[-1].vec:', curve[-1].vec #----- - curve[-1].handleTypes = [ALIGN, FREE] #remi--todo----- - curve[-1].radius = 1.0 - - - - else: #-- only straight line- and arc-segments----OK------ - #print 'deb:polyline2dCurve.draw curve:', curve #----- - points = [] - arc_res = settings.var['curve_arc'] - prevHandleType = VECT - #d_points.append(d_points[0]) #------ first vertex added at the end of list -------- - #curve.setType(0) #polygon_type of Blender_curve - for i in xrange(len(d_points)): - point1 = d_points[i] - #point2 = d_points[i+1] - #----- optimised Bezier-Handles calculation -------------------------------- - #print 'deb:drawPlineCurve: i:', i #--------- - if point1.bulge and not (i == len(d_points)-1 and point1.bulge and not self.closed): - if i == len(d_points)-1: point2 = d_points[0] - else: point2 = d_points[i+1] - - - # calculate additional points for bulge - VectorTriples = calcBulge(point1, point2, arc_res, triples=True) - - if prevHandleType == FREE: - #print 'deb:drawPlineCurve: VectorTriples[0]:', VectorTriples[0] #--------- - VectorTriples[0][:3] = prevHandleVect - #print 'deb:drawPlineCurve: VectorTriples[0]:', VectorTriples[0] #--------- - - if i == 0: curve = pline.appendNurb(BezTriple.New(VectorTriples[0])) - else: curve.append(BezTriple.New(VectorTriples[0])) - curve[-1].handleTypes = [prevHandleType, FREE] - curve[-1].radius = 1.0 - - for p in VectorTriples[1:-1]: - curve.append(BezTriple.New(p)) - curve[-1].handleTypes = [FREE, FREE] - curve[-1].radius = 1.0 - - prevHandleVect = VectorTriples[-1][:3] - prevHandleType = FREE - #print 'deb:drawPlineCurve: prevHandleVect:', prevHandleVect #--------- - else: - #print 'deb:drawPlineCurve: else' #---------- - if prevHandleType == FREE: - VectorTriples = prevHandleVect + list(point1) + list(point1) - #print 'deb:drawPlineCurve: VectorTriples:', VectorTriples #--------- - curve.append(BezTriple.New(VectorTriples)) - curve[-1].handleTypes = [FREE, VECT] - prevHandleType = VECT - curve[-1].radius = 1.0 - else: - if i == 0: curve = pline.appendNurb(BezTriple.New(point1.loc)) - else: curve.append(BezTriple.New(point1.loc)) - curve[-1].handleTypes = [VECT, VECT] - curve[-1].radius = 1.0 - #print 'deb:drawPlineCurve: curve[-1].vec[0]', curve[-1].vec[0] #---------- - - if self.closed: - curve.flagU = 1 # Set curve cyclic=close - if prevHandleType == FREE: - #print 'deb:drawPlineCurve:closed curve[0].vec:', curve[0].vec #---------- - #print 'deb:drawPlineCurve:closed curve[0].handleTypes:', curve[0].handleTypes #---------- - prevHandleType2 = curve[0].handleTypes[1] - p0h1,p0,p0h2 = curve[0].vec - #print 'deb:drawPlineCurve:closed p0h1:', p0h1 #---------- - p0h1 = prevHandleVect - #p0h1 = [0,0,0] - #print 'deb:drawPlineCurve:closed p0h1:', p0h1 #---------- - #curve[0].vec = [p0h1,p0,p0h2] - curve.__setitem__(0,BezTriple.New(p0h1+p0+p0h2)) - - curve[0].handleTypes = [FREE,prevHandleType2] - curve[0].radius = 1.0 - #print 'deb:drawPlineCurve:closed curve[0].vec:', curve[0].vec #---------- - #print 'deb:drawPlineCurve:closed curve[0].handleTypes:', curve[0].handleTypes #---------- - else: - curve[0].handleTypes[0] = VECT - curve[0].radius = 1.0 - else: - curve.flagU = 0 # Set curve not cyclic=open - - if settings.var['fill_on']: - pline.setFlag(6) # 2+4 set top and button caps - else: - pline.setFlag(pline.getFlag() & ~6) # dont set top and button caps - - pline.setResolu(settings.var['curve_res']) - pline.update() - ob = SCENE.objects.new(pline) # create a new curve_object - - if thic != 0.0: #hack: Blender<2.45 curve-extrusion - thic = thic * 0.5 - pline.setExt1(1.0) # curve-extrusion accepts only (0.0 - 2.0) - ob.LocZ = thic + LocZ - - transform(self.extrusion, 0, ob) - if thic != 0.0: - ob.SizeZ *= abs(thic) - - #print 'deb:polyline2dCurve.draw.END:----------------' #----- - return ob - - - def drawPoly2d(self, settings): #---- 2dPolyline - plane lines/arcs with wide/thic - """Generate the geometery of regular polyline. - """ - #print 'deb:polyline2d.draw.START:----------------' #------------------------ - points = [] - d_points = [] - swidths = [] - ewidths = [] - swidth_default = self.swidth #default start width of POLYLINEs segments - ewidth_default = self.ewidth #default end width of POLYLINEs segments - #print 'deb:drawPoly2d self.swidth=', self.swidth #------------------------ - thic = set_thick(self.thic, settings) - if self.spline: pline_typ = 'ps' - elif self.curved: pline_typ = 'pc' - else: pline_typ = 'pl' - obname = '%s_%s' %(pline_typ, self.layer) # create object_name from layer name - obname = obname[:MAX_NAMELENGTH] - - if len(self.points) < 2: - #print 'deb:drawPoly2d exit, cause POLYLINE has less than 2 vertices' #--------- - return - - if settings.var['Z_force_on']: - self.elevation = settings.var['Z_elev'] - for point in self.points: - point.loc[2] = self.elevation - d_points.append(point) - else: #for DXFr10-format: update all non-existing LocZ points[].loc[2] == None -> 0.0 elevation - for point in self.points: - if point.loc[2] == None: - point.loc[2] = self.elevation - d_points.append(point) - #print 'deb:drawPoly2d len of d_pointsList ====== ', len(d_points) #------------------------ - #print 'deb:drawPoly2d d_pointsList ======:\n ', d_points #------------------------ - - - #if closed polyline, add duplic of the first vertex at the end of pointslist - if self.closed: #new_b8 - if d_points[-1].loc != d_points[0].loc: # if not equal, then set the first at the end of pointslist - d_points.append(d_points[0]) - else: - if d_points[-1].loc == d_points[0].loc: # if equal, then set to closed, and modify the last point - d_points[-1] = d_points[0] - self.closed = True - #print 'deb:drawPoly2d len of d_pointsList ====== ', len(d_points) #------------------------ - #print 'deb:drawPoly2d d_pointsList ======:\n ', d_points #------------------------ - - d_points = self.doubles_out(settings, d_points) - #print 'deb:drawPolyCurve d_pointsList =after DV-outsorting=====:\n ', d_points #------------------------ - - #print 'deb:drawPoly2d len of d_pointsList ====== ', len(d_points) #------------------------ - if len(d_points) < 2: #if too few vertex, then return - #print 'deb:drawPoly2d corrupted Vertices' #--------- - return - - # analyze of straight- and bulge-segments - # generation of additional points for bulge segments - arc_res = settings.var['arc_res']/sqrt(settings.var['arc_rad']) - wide_segment_exist = False - bulg_points = [] # for each point set None (or center for arc-subPoints) - for i in xrange(len(d_points)-1): - point1 = d_points[i] - point2 = d_points[i+1] - #print 'deb:drawPoly2d_bulg tocalc.point1:', point1 #------------------------ - #print 'deb:drawPoly2d_bulg tocalc.point2:', point2 #------------------------ - - swidth = point1.swidth - ewidth = point1.ewidth - #print 'deb:drawPoly2d point1.swidth=', swidth #------------------------ - if swidth == None: swidth = swidth_default - if ewidth == None: ewidth = ewidth_default - if swidth != 0.0 or ewidth != 0.0: wide_segment_exist = True - #print 'deb:drawPoly2d vertex_swidth=', swidth #------------------------ - - if settings.var['width_force']: # force minimal width for thin segments - width_min = settings.var['width_min'] - if swidth < width_min: swidth = width_min - if ewidth < width_min: ewidth = width_min - if not settings.var['width_on']: # then force minimal width for all segments - swidth = width_min - ewidth = width_min - - #if point1.bulge and (i < (len(d_points)-1) or self.closed): - if point1.bulge and i < (len(d_points)-1): #10_b8 - verts, center = calcBulge(point1, point2, arc_res) #calculate additional points for bulge - points.extend(verts) - delta_width = (ewidth - swidth) / len(verts) - width_list = [swidth + (delta_width * ii) for ii in xrange(len(verts)+1)] - swidths.extend(width_list[:-1]) - ewidths.extend(width_list[1:]) - bulg_list = [center for ii in xrange(len(verts))] - #the last point in bulge has index False for better indexing of bulg_end! - bulg_list[-1] = None - bulg_points.extend(bulg_list) - - else: - points.append(point1.loc) - swidths.append(swidth) - ewidths.append(ewidth) - bulg_points.append(None) - points.append(d_points[-1].loc) - - - #--calculate width_vectors: left-side- and right-side-points ---------------- - # 1.level:IF width --------------------------------------- - if (settings.var['width_on'] and wide_segment_exist) or settings.var['width_force']: - #new_b8 points.append(d_points[0].loc) #temporarly add first vertex at the end (for better loop) - dist_min05 = 0.5 * settings.var['dist_min'] #minimal width for zero_witdh - - pointsLs = [] # list of left-start-points - pointsLe = [] # list of left-end-points - pointsRs = [] # list of right-start-points - pointsRe = [] # list of right-end-points - pointsW = [] # list of all border-points - #rotMatr90 = Mathutils.Matrix(rotate 90 degree around Z-axis) = normalvectorXY - rotMatr90 = Mathutils.Matrix([0, -1, 0], [1, 0, 0], [0, 0, 1]) - bulg_in = False - last_bulg_point = False - for i in xrange(len(points)-1): - point1 = points[i] - point2 = points[i+1] - point1vec = Mathutils.Vector(point1) - point2vec = Mathutils.Vector(point2) - swidth05 = swidths[i] * 0.5 - ewidth05 = ewidths[i] * 0.5 - if swidth05 == 0: swidth05 = dist_min05 - if ewidth05 == 0: ewidth05 = dist_min05 - normal_vector = rotMatr90 * (point2vec-point1vec).normalize() - if last_bulg_point: - last_bulg_point = False - bulg_in = True - elif bulg_points[i] != None: - centerVec = Mathutils.Vector(bulg_points[i]) - if bulg_points[i+1] == None: last_bulg_point = True - bulg_in = True - else: bulg_in = False - - if bulg_in: - #makes clean intersections for arc-segments - radius1vec = point1vec - centerVec - radius2vec = point2vec - centerVec - angle = Mathutils.AngleBetweenVecs(normal_vector, radius1vec) - if angle < 90.0: - normal_vector1 = radius1vec.normalize() - normal_vector2 = radius2vec.normalize() - else: - normal_vector1 = - radius1vec.normalize() - normal_vector2 = - radius2vec.normalize() - - swidth05vec = swidth05 * normal_vector1 - ewidth05vec = ewidth05 * normal_vector2 - pointsLs.append(point1vec + swidth05vec) #vertex left start - pointsRs.append(point1vec - swidth05vec) #vertex right start - pointsLe.append(point2vec + ewidth05vec) #vertex left end - pointsRe.append(point2vec - ewidth05vec) #vertex right end - - else: - swidth05vec = swidth05 * normal_vector - ewidth05vec = ewidth05 * normal_vector - pointsLs.append(point1vec + swidth05vec) #vertex left start - pointsRs.append(point1vec - swidth05vec) #vertex right start - pointsLe.append(point2vec + ewidth05vec) #vertex left end - pointsRe.append(point2vec - ewidth05vec) #vertex right end - - # additional last point is also calculated - #pointsLs.append(pointsLs[0]) - #pointsRs.append(pointsRs[0]) - #pointsLe.append(pointsLe[0]) - #pointsRe.append(pointsRe[0]) - - pointsLc, pointsRc = [], [] # lists Left/Right corners = intersection points - - # 2.level:IF width and corner-trim - if settings.var['pl_trim_on']: #optional clean corner-intersections - # loop preset - # set STARTpoints of the first point points[0] - if not self.closed: - pointsLc.append(pointsLs[0]) - pointsRc.append(pointsRs[0]) - else: - pointsLs.append(pointsLs[0]) - pointsRs.append(pointsRs[0]) - pointsLe.append(pointsLe[0]) - pointsRe.append(pointsRe[0]) - points.append(points[0]) - vecL3, vecL4 = pointsLs[0], pointsLe[0] - vecR3, vecR4 = pointsRs[0], pointsRe[0] - lenL = len(pointsLs)-1 - #print 'deb:drawPoly2d pointsLs():\n', pointsLs #---------------- - #print 'deb:drawPoly2d lenL, len.pointsLs():', lenL,',', len(pointsLs) #---------------- - bulg_in = False - last_bulg_point = False - - # LOOP: makes (ENDpoints[i],STARTpoints[i+1]) - for i in xrange(lenL): - if bulg_points[i] != None: - if bulg_points[i+1] == None: #makes clean intersections for arc-segments - last_bulg_point = True - if not bulg_in: - bulg_in = True - #pointsLc.extend((points[i], pointsLs[i])) - #pointsRc.extend((points[i], pointsRs[i])) - vecL1, vecL2 = vecL3, vecL4 - vecR1, vecR2 = vecR3, vecR4 - vecL3, vecL4 = pointsLs[i+1], pointsLe[i+1] - vecR3, vecR4 = pointsRs[i+1], pointsRe[i+1] - #compute left- and right-cornerpoints - #cornerpointL = Geometry.LineIntersect2D(vec1, vec2, vec3, vec4) - cornerpointL = Mathutils.LineIntersect(vecL1, vecL2, vecL3, vecL4) - cornerpointR = Mathutils.LineIntersect(vecR1, vecR2, vecR3, vecR4) - #print 'deb:drawPoly2d cornerpointL: ', cornerpointL #------------- - #print 'deb:drawPoly2d cornerpointR: ', cornerpointR #------------- - - # IF not cornerpoint THEN check if identic start-endpoints (=collinear segments) - if cornerpointL == None or cornerpointR == None: - if vecL2 == vecL3 and vecR2 == vecR3: - #print 'deb:drawPoly2d pointVec: ####### identic ##########' #---------------- - pointsLc.append(pointsLe[i]) - pointsRc.append(pointsRe[i]) - else: - pointsLc.extend((pointsLe[i],points[i+1],pointsLs[i+1])) - pointsRc.extend((pointsRe[i],points[i+1],pointsRs[i+1])) - else: - cornerpointL = cornerpointL[0] # because Mathutils.LineIntersect() -> (pkt1,pkt2) - cornerpointR = cornerpointR[0] - #print 'deb:drawPoly2d cornerpointL: ', cornerpointL #------------- - #print 'deb:drawPoly2d cornerpointR: ', cornerpointR #------------- - pointVec0 = Mathutils.Vector(points[i]) - pointVec = Mathutils.Vector(points[i+1]) - pointVec2 = Mathutils.Vector(points[i+2]) - #print 'deb:drawPoly2d pointVec0: ', pointVec0 #------------- - #print 'deb:drawPoly2d pointVec: ', pointVec #------------- - #print 'deb:drawPoly2d pointVec2: ', pointVec2 #------------- - # if diststance(cornerL-center-cornerR) < limiter * (seg1_endWidth + seg2_startWidth) - max_cornerDist = (vecL2 - vecR2).length + (vecL3 - vecR3).length - is_cornerDist = (cornerpointL - pointVec).length + (cornerpointR - pointVec).length - #corner_angle = Mathutils.AngleBetweenVecs((pointVec0 - pointVec),(pointVec - pointVec2)) - #print 'deb:drawPoly2d corner_angle: ', corner_angle #------------- - #print 'deb:drawPoly2d max_cornerDist, is_cornerDist: ', max_cornerDist, is_cornerDist #------------- - #if abs(corner_angle) < 90.0: - # intersection --------- limited by TRIM_LIMIT (1.0 - 5.0) - if is_cornerDist < max_cornerDist * settings.var['pl_trim_max']: - # clean corner intersection - pointsLc.append(cornerpointL) - pointsRc.append(cornerpointR) - else: - pointsLc.extend((pointsLe[i],points[i+1],pointsLs[i+1])) - pointsRc.extend((pointsRe[i],points[i+1],pointsRs[i+1])) - if not self.closed: - pointsLc.append(pointsLe[-1]) - pointsRc.append(pointsRe[-1]) - - # 2.level:IF width but no-trim - else: - # loop preset - # set STARTpoints of the first point points[0] - if not self.closed: - pointsLc.append(pointsLs[0]) - pointsRc.append(pointsRs[0]) - else: - pointsLs.append(pointsLs[0]) - pointsRs.append(pointsRs[0]) - pointsLe.append(pointsLe[0]) - pointsRe.append(pointsRe[0]) - points.append(points[0]) - vecL3, vecL4 = pointsLs[0], pointsLe[0] - vecR3, vecR4 = pointsRs[0], pointsRe[0] - lenL = len(pointsLs)-1 - #print 'deb:drawPoly2d pointsLs():\n', pointsLs #---------------- - #print 'deb:drawPoly2d lenL, len.pointsLs():', lenL,',', len(pointsLs) #---------------- - bulg_in = False - last_bulg_point = False - - # LOOP: makes (ENDpoints[i],STARTpoints[i+1]) - for i in xrange(lenL): - vecL1, vecL2 = vecL3, vecL4 - vecR1, vecR2 = vecR3, vecR4 - vecL3, vecL4 = pointsLs[i+1], pointsLe[i+1] - vecR3, vecR4 = pointsRs[i+1], pointsRe[i+1] - if bulg_points[i] != None: - #compute left- and right-cornerpoints - cornerpointL = Mathutils.LineIntersect(vecL1, vecL2, vecL3, vecL4) - cornerpointR = Mathutils.LineIntersect(vecR1, vecR2, vecR3, vecR4) - pointsLc.append(cornerpointL[0]) - pointsRc.append(cornerpointR[0]) - else: # IF non-bulg - pointsLc.extend((pointsLe[i],points[i+1],pointsLs[i+1])) - pointsRc.extend((pointsRe[i],points[i+1],pointsRs[i+1])) - if not self.closed: - pointsLc.append(pointsLe[-1]) - pointsRc.append(pointsRe[-1]) - - len1 = len(pointsLc) - #print 'deb:drawPoly2d len1:', len1 #----------------------- - #print 'deb:drawPoly2d len1 len(pointsLc),len(pointsRc):', len(pointsLc),len(pointsRc) #----------------------- - pointsW = pointsLc + pointsRc # all_points_List = left_side + right_side - #print 'deb:drawPoly2d pointsW():\n', pointsW #---------------- - - # 2.level:IF width and thickness --------------------- - if thic != 0: - thic_pointsW = [] - thic_pointsW.extend([[point[0], point[1], point[2]+thic] for point in pointsW]) - if thic < 0.0: - thic_pointsW.extend(pointsW) - pointsW = thic_pointsW - else: - pointsW.extend(thic_pointsW) - faces = [] - f_start, f_end = [], [] - f_bottom = [[num, num+1, len1+num+1, len1+num] for num in xrange(len1-1)] - f_top = [[num, len1+num, len1+num+1, num+1] for num in xrange(len1+len1, len1+len1+len1-1)] - f_left = [[num, len1+len1+num, len1+len1+num+1, num+1] for num in xrange(len1-1)] - f_right = [[num, num+1, len1+len1+num+1, len1+len1+num] for num in xrange(len1, len1+len1-1)] - - if self.closed: - f_bottom.append([len1-1, 0, len1, len1+len1-1]) #bottom face - f_top.append( [len1+len1+len1-1, len1+len1+len1+len1-1, len1+len1+len1, len1+len1+0]) #top face - f_left.append( [0, len1-1, len1+len1+len1-1, len1+len1]) #left face - f_right.append( [len1, len1+len1+len1, len1+len1+len1+len1-1, len1+len1-1]) #right face - else: - f_start = [[0, len1, len1+len1+len1, len1+len1]] - f_end = [[len1+len1-1, 0+len1-1, len1+len1+len1-1, len1+len1+len1+len1-1]] - - faces = f_left + f_right + f_bottom + f_top + f_start + f_end - #faces = f_bottom + f_top - #faces = f_left + f_right + f_start + f_end - #print 'deb:faces_list:\n', faces #----------------------- - if M_OBJ: obname, me, ob = makeNewObject() - else: - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - me.verts.extend(pointsW) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - - # each MeshSide becomes vertexGroup for easier material assignment --------------------- - # The mesh must first be linked to an object so the method knows which object to update. - # This is because vertex groups in Blender are stored in the object -- not in the mesh, - # which may be linked to more than one object. - if settings.var['vGroup_on'] and not M_OBJ: - # each MeshSide becomes vertexGroup for easier material assignment --------------------- - replace = Mesh.AssignModes.REPLACE #or .AssignModes.ADD - vg_left, vg_right, vg_top, vg_bottom = [], [], [], [] - for v in f_left: vg_left.extend(v) - for v in f_right: vg_right.extend(v) - for v in f_top: vg_top.extend(v) - for v in f_bottom: vg_bottom.extend(v) - me.addVertGroup('side.left') ; me.assignVertsToGroup('side.left', vg_left, 1.0, replace) - me.addVertGroup('side.right') ; me.assignVertsToGroup('side.right', vg_right, 1.0, replace) - me.addVertGroup('side.top') ; me.assignVertsToGroup('side.top', vg_top, 1.0, replace) - me.addVertGroup('side.bottom'); me.assignVertsToGroup('side.bottom',vg_bottom, 1.0, replace) - if not self.closed: - me.addVertGroup('side.start'); me.assignVertsToGroup('side.start', f_start[0], 1.0, replace) - me.addVertGroup('side.end') ; me.assignVertsToGroup('side.end', f_end[0], 1.0, replace) - - if settings.var['meshSmooth_on']: # left and right side become smooth ---------------------- - #if self.spline or self.curved: - smooth_len = len(f_left) + len(f_right) - for i in xrange(smooth_len): - me.faces[i].smooth = True - #me.Modes(AUTOSMOOTH) - - # 2.level:IF width, but no-thickness --------------------- - else: - faces = [] - faces = [[num, len1+num, len1+num+1, num+1] for num in xrange(len1 - 1)] - if self.closed: - faces.append([len1, 0, len1-1, len1+len1-1]) - if M_OBJ: obname, me, ob = makeNewObject() - else: - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - me.verts.extend(pointsW) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - - - # 1.level:IF no-width, but thickness --------------------- - elif thic != 0: - len1 = len(points) - thic_points = [] - thic_points.extend([[point[0], point[1], point[2]+thic] for point in points]) - if thic < 0.0: - thic_points.extend(points) - points = thic_points - else: - points.extend(thic_points) - faces = [] - faces = [[num, num+1, num+len1+1, num+len1] for num in xrange(len1 - 1)] - if self.closed: - faces.append([len1-1, 0, len1, 2*len1-1]) - if M_OBJ: obname, me, ob = makeNewObject() - else: - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - me.verts.extend(points) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - - if settings.var['meshSmooth_on']: # left and right side become smooth ---------------------- - #if self.spline or self.curved: - for i in xrange(len(faces)): - me.faces[i].smooth = True - #me.Modes(AUTOSMOOTH) - - # 1.level:IF no-width and no-thickness --------------------- - else: - edges = [[num, num+1] for num in xrange(len(points)-1)] - if self.closed: - edges.append([len(points)-1, 0]) - if M_OBJ: obname, me, ob = makeNewObject() - else: - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - me.verts.extend(points) # add vertices to mesh - me.edges.extend(edges) # add edges to the mesh - - transform(self.extrusion, 0, ob) - #print 'deb:polyline.draw.END:----------------' #----------------------- - return ob - - - - -class Vertex(object): #----------------------------------------------------------------- - """Generic vertex object used by POLYLINEs, (and maybe others). - also used by class_LWPOLYLINEs but without obj-parameter - """ - - def __init__(self, obj=None): - """Initializes vertex data. - - The optional obj arg is an entity object of type vertex. - """ - #print 'deb:Vertex.init.START:----------------' #----------------------- - self.loc = [0,0,0] - self.face = [] - self.swidth = None #0 - self.ewidth = None #0 - self.bulge = 0 - self.tangent = False - self.weight = 1.0 - if obj is not None: - if not obj.type == 'vertex': - raise TypeError, "Wrong type %s for vertex object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - self.get_props(obj) - else: - pass - #print 'deb:Vertex.init.END:----------------' #------------------------ - - - def get_props(self, data): - """Gets coords for a VERTEX type object. - - Each vert can have a number of properties. - Verts should be coded as - 10:xvalue - 20:yvalue - 40:startwidth or 0 - 41:endwidth or 0 - 42:bulge or 0 - """ - self.x = getit(data, 10, None) - self.y = getit(data, 20, None) - self.z = getit(data, 30, None) - - self.flags = getit(data, 70, 0) # flags - self.curved = self.flags&1 # Bezier-curve-fit:additional-vertex - self.curved_t = self.flags&2 # Bezier-curve-fit:tangent exists - self.spline = self.flags&8 # NURBSpline-fit:additional-vertex - self.spline_c = self.flags&16 # NURBSpline-fit:control-vertex - self.poly3d = self.flags&32 # polyline3d:control-vertex - self.plmesh = self.flags&64 # polymesh3d:control-vertex - self.plface = self.flags&128 # polyface - - # if PolyFace.Vertex with Face_definition - if self.curved_t: - self.curve_tangent = getit(data, 50, None) # curve_tangent - if not self.curve_tangent==None: - self.tangent = True - #elif self.spline_c: # NURBSpline:control-vertex - # self.weight = getit(data, 41, 1.0) # weight od control point - - elif self.plface and not self.plmesh: - v1 = getit(data, 71, 0) # polyface:Face.vertex 1. - v2 = getit(data, 72, 0) # polyface:Face.vertex 2. - v3 = getit(data, 73, 0) # polyface:Face.vertex 3. - v4 = getit(data, 74, None) # polyface:Face.vertex 4. - self.face = [abs(v1)-1,abs(v2)-1,abs(v3)-1] - if v4 != None: - if abs(v4) != abs(v1): - self.face.append(abs(v4)-1) - else: #--parameter for polyline2d - self.swidth = getit(data, 40, None) # start width - self.ewidth = getit(data, 41, None) # end width - self.bulge = getit(data, 42, 0) # bulge of segment - - - def __len__(self): - return 3 - - - def __getitem__(self, key): - return self.loc[key] - - - def __setitem__(self, key, value): - if key in [0,1,2]: - self.loc[key] - - - def __iter__(self): - return self.loc.__iter__() - - - def __str__(self): - return str(self.loc) - - - def __repr__(self): - return "Vertex %s, swidth=%s, ewidth=%s, bulge=%s, face=%s" %(self.loc, self.swidth, self.ewidth, self.bulge, self.face) - - - def getx(self): - return self.loc[0] - def setx(self, value): - self.loc[0] = value - x = property(getx, setx) - - - def gety(self): - return self.loc[1] - def sety(self, value): - self.loc[1] = value - y = property(gety, sety) - - - def getz(self): - return self.loc[2] - def setz(self, value): - self.loc[2] = value - z = property(getz, setz) - - - -class Spline(Polyline): #----------------------------------------------------------------- - """Class for objects representing dxf SPLINEs. - """ - """Expects an entity object of type spline as input. -100 - Subclass marker (AcDbSpline) -210,220, 230 - Normal vector (omitted if the spline is nonplanar) X,Y,Z values of normal vector -70 - Spline flag (bit coded): - 1 = Closed spline - 2 = Periodic spline - 4 = Rational spline - 8 = Planar - 16 = Linear (planar bit is also set) -71 - Degree of the spline curve -72 - Number of knots -73 - Number of control points -74 - Number of fit points (if any) -42 - Knot tolerance (default = 0.0000001) -43 - Control-point tolerance (default = 0.0000001) -44 - Fit tolerance (default = 0.0000000001) -12,22,32 - Start tangent--may be omitted (in WCS). X,Y,Z values of start tangent--may be omitted (in WCS). -13,23, 33 - End tangent--may be omitted (in WCS). X,Y,Z values of end tangent--may be omitted (in WCS) -40 - Knot value (one entry per knot) -41 - Weight (if not 1); with multiple group pairs, are present if all are not 1 -10,20, 30 - Control points (in WCS) one entry per control point. -DXF: X value; APP: 3D point, Y and Z values of control points (in WCS) (one entry per control point) -11,21, 31 - Fit points (in WCS) one entry per fit point. - X,Y,Z values of fit points (in WCS) (one entry per fit point) - """ - def __init__(self, obj): - #print 'deb:Spline.START:----------------' #------------------------ - if not obj.type == 'spline': - raise TypeError, "Wrong type %s for spline object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - - # required data - self.num_points = obj.get_type(73)[0] - - # optional data (with defaults) - self.space = getit(obj, 67, 0) - - self.color_index = getit(obj, 62, BYLAYER) - - #self.elevation = getit(obj, 30, 0) - self.thic = 0 # getit(obj, 39, 0) - - width = 0 - self.swidth = width # default start width - self.ewidth = width # default end width - - self.flags = getit(obj, 70, 0) - self.closed = self.flags & 1 # closed spline - self.period = self.flags & 2 # Periodic spline - self.ration = self.flags & 4 # Rational spline - self.planar = self.flags & 8 # Planar - self.linear = self.flags & 16 # Linear (and Planar) - - self.curvNoFitted = False - self.curvQuadrati = False - self.curvCubicBsp = False - self.curvBezier = False - self.degree = getit(obj, 71, 0) # Degree of the spline curve - if self.degree == 0: self.curvNoFitted = True - elif self.degree == 1: self.curvQuadrati = True - elif self.degree == 2: self.curvCubicBsp = True - #elif self.degree == 3: self.curvBezier = True - #elif self.degree == 3: self.spline = True - - self.knotpk_len = getit(obj, 72, 0) # Number of knots - self.ctrlpk_len = getit(obj, 73, 0) # Number of control points - self.fit_pk_len = getit(obj, 74, 0) # Number of fit points (if any) - - #TODO: import SPLINE as Bezier curve directly, possible? - #print 'deb:Spline self.fit_pk_len=', self.fit_pk_len #------------------------ - #self.fit_pk_len = 0 # temp for debug - if self.fit_pk_len and settings.var['splines_as']==5: - self.spline = False - self.curved = True - else: - self.spline = True - self.curved = False - - self.knotpk_tol = getit(obj, 42, 0.0000001) # Knot tolerance (default = 0.0000001) - self.ctrlpk_tol = getit(obj, 43, 0.0000001) # Control-point tolerance (default = 0.0000001) - self.fit_pk_tol = getit(obj, 44, 0.0000000001) # Fit tolerance (default = 0.0000000001) - - self.layer = getit(obj, 8, None) - self.extrusion = get_extrusion(obj) - - self.pltype = 'spline' # spline is a 2D- or 3D-polyline - - self.points = self.get_points(obj.data) - #self.knots_val = self.get_knots_val(obj.data) # 40 - Knot value (one entry per knot) - #self.knots_wgh = self.get_knots_wgh(obj.data) # 41 - Weight (default 1) - - #print 'deb:Spline obj.data:\n', obj.data #------------------------ - #print 'deb:Spline self.points:\n', self.points #------------------------ - #print 'deb:Spline.ENDinit:----------------' #------------------------ - - - def get_points(self, data): - """Gets points for a spline type object. - - Splines have fixed number of verts, and - each vert can have a number of properties. - Verts should be coded as - 10:xvalue - 20:yvalue - for each vert - """ - point = None - points = [] - pointend = None - #point = Vertex() - if self.spline: # NURBSpline definition - for item in data: - #print 'deb:Spline.get_points spilne_item:', item #------------------------ - if item[0] == 10: # control point - if point: points.append(point) - point = Vertex() - point.curved = True - point.x = item[1] - elif item[0] == 20: # 20 = y - point.y = item[1] - elif item[0] == 30: # 30 = z - point.z = item[1] - elif item[0] == 41: # 41 = weight - point.weight = item[1] - #print 'deb:Spline.get_points control point:', point #------------------------ - - elif self.curved: # Bezier definition - for item in data: - #print 'deb:Spline.get_points curved_item:', item #------------------------ - if item[0] == 11: # fit point - if point: points.append(point) - point = Vertex() - point.tangent = False - point.x = item[1] - elif item[0] == 21: # 20 = y - point.y = item[1] - elif item[0] == 31: # 30 = z - point.z = item[1] - #print 'deb:Spline.get_points fit point:', point #------------------------ - - elif item[0] == 12: # start tangent - if point: points.append(point) - point = Vertex() - point.tangent = True - point.x = item[1] - elif item[0] == 22: # = y - point.y = item[1] - elif item[0] == 32: # = z - point.z = item[1] - #print 'deb:Spline.get_points fit begtangent:', point #------------------------ - - elif item[0] == 13: # end tangent - if point: points.append(point) - pointend = Vertex() - pointend.tangent = True - pointend.x = item[1] - elif item[0] == 23: # 20 = y - pointend.y = item[1] - elif item[0] == 33: # 30 = z - pointend.z = item[1] - #print 'deb:Spline.get_points fit endtangent:', pointend #------------------------ - points.append(point) - if self.curved and pointend: - points.append(pointend) - #print 'deb:Spline points:\n', points #------------------------ - return points - - def __repr__(self): - return "%s: layer - %s, points - %s" %(self.__class__.__name__, self.layer, self.points) - - - -class LWpolyline(Polyline): #------------------------------------------------------------- - """Class for objects representing dxf LWPOLYLINEs. - """ - def __init__(self, obj): - """Expects an entity object of type lwpolyline as input. - """ - #print 'deb:LWpolyline.START:----------------' #------------------------ - if not obj.type == 'lwpolyline': - raise TypeError, "Wrong type %s for polyline object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - - # required data - self.num_points = obj.get_type(90)[0] - - # optional data (with defaults) - self.space = getit(obj, 67, 0) - self.elevation = getit(obj, 38, 0) - self.thic = getit(obj, 39, 0) - self.color_index = getit(obj, 62, BYLAYER) - width = getit(obj, 43, 0) - self.swidth = width # default start width - self.ewidth = width # default end width - #print 'deb:LWpolyline width=', width #------------------------ - #print 'deb:LWpolyline elevation=', self.elevation #------------------------ - - self.flags = getit(obj, 70, 0) - self.closed = self.flags&1 # byte coded, 1 = closed, 128 = plinegen - - self.layer = getit(obj, 8, None) - self.extrusion = get_extrusion(obj) - - self.points = self.get_points(obj.data) - - self.pltype = 'poly2d' # LW-polyline is a 2D-polyline - self.spline = False - self.curved = False - - #print 'deb:LWpolyline.obj.data:\n', obj.data #------------------------ - #print 'deb:LWpolyline.ENDinit:----------------' #------------------------ - - - def get_points(self, data): - """Gets points for a polyline type object. - - LW-Polylines have no fixed number of verts, and - each vert can have a number of properties. - Verts should be coded as - 10:xvalue - 20:yvalue - 40:startwidth or 0 - 41:endwidth or 0 - 42:bulge or 0 - for each vert - """ - num = self.num_points - point = None - points = [] - for item in data: - if item[0] == 10: # 10 = x - if point: - points.append(point) - point = Vertex() - point.x = item[1] - point.z = self.elevation - elif item[0] == 20: # 20 = y - point.y = item[1] - elif item[0] == 40: # 40 = start width - point.swidth = item[1] - elif item[0] == 41: # 41 = end width - point.ewidth = item[1] - elif item[0] == 42: # 42 = bulge - point.bulge = item[1] - points.append(point) - return points - - - def __repr__(self): - return "%s: layer - %s, points - %s" %(self.__class__.__name__, self.layer, self.points) - - -class Text: #----------------------------------------------------------------- - """Class for objects representing dxf TEXT. - """ - def __init__(self, obj): - """Expects an entity object of type text as input. - """ - if not obj.type == 'text': - raise TypeError, "Wrong type %s for text object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - - # required data - self.height = 1.7 * obj.get_type(40)[0] #text.height - self.value = obj.get_type(1)[0] #The text string value - - # optional data (with defaults) - self.space = getit(obj, 67, 0) - self.color_index = getit(obj, 62, BYLAYER) - self.thic = getit(obj, 39, 0) - - self.rotation = getit(obj, 50, 0) # radians - self.width_factor = getit(obj, 41, 1) # Scaling factor along local x axis - self.oblique = getit(obj, 51, 0) # oblique angle: skew in degrees -90 <= oblique <= 90 - - #self.style = getit(obj, 7, 'STANDARD') # --todo---- Text style name (optional, default = STANDARD) - - #Text generation flags (optional, default = 0): - #2 = backward (mirrored in X), - #4 = upside down (mirrored in Y) - self.flags = getit(obj, 71, 0) - self.mirrorX, self.mirrorY = 1.0, 1.0 - if self.flags&2: self.mirrorX = - 1.0 - if self.flags&4: self.mirrorY = - 1.0 - - # vertical.alignment: 0=baseline, 1=bottom, 2=middle, 3=top - self.valignment = getit(obj, 73, 0) - #Horizontal text justification type (optional, default = 0) integer codes (not bit-coded) - #0=left, 1=center, 2=right - #3=aligned, 4=middle, 5=fit - self.halignment = getit(obj, 72, 0) - - self.layer = getit(obj, 8, None) - self.loc1, self.loc2 = self.get_loc(obj) - if self.loc2[0] != None and self.halignment != 5: - self.loc = self.loc2 - else: - self.loc = self.loc1 - self.extrusion = get_extrusion(obj) - - - def get_loc(self, data): - """Gets adjusted location for text type objects. - - If group 72 and/or 73 values are nonzero then the first alignment point values - are ignored and AutoCAD calculates new values based on the second alignment - point and the length and height of the text string itself (after applying the - text style). If the 72 and 73 values are zero or missing, then the second - alignment point is meaningless. - I don't know how to calc text size... - """ - # bottom left x, y, z and justification x, y, z = 0 - #x, y, z, jx, jy, jz = 0, 0, 0, 0, 0, 0 - x = getit(data, 10, None) #First alignment point (in OCS). - y = getit(data, 20, None) - z = getit(data, 30, 0.0) - jx = getit(data, 11, None) #Second alignment point (in OCS). - jy = getit(data, 21, None) - jz = getit(data, 31, 0.0) - return [x, y, z],[jx, jy, jz] - - - def __repr__(self): - return "%s: layer - %s, value - %s" %(self.__class__.__name__, self.layer, self.value) - - - def draw(self, settings): - """for TEXTs: generate Blender_geometry. - """ - obname = 'tx_%s' %self.layer # create object name from layer name - obname = obname[:MAX_NAMELENGTH] - txt = Text3d.New(obname) - ob = SCENE.objects.new(txt) # create a new text_object - - txt.setText(self.value) - txt.setSize(1.0) #Blender<2.45 accepts only (0.0 - 5.0) - #txt.setSize(self.height) - #txt.setWidth(self.bold) - #setLineSeparation(sep) - txt.setShear(self.oblique/90) - - thic = set_thick(self.thic, settings) - if thic != 0.0: - thic = self.thic * 0.5 - self.loc[2] += thic - txt.setExtrudeDepth(1.0) #Blender<2.45 accepts only (0.1 - 10.0) - if self.halignment == 0: - align = Text3d.LEFT - elif self.halignment == 1: - align = Text3d.MIDDLE - elif self.halignment == 2: - align = Text3d.RIGHT - else: - align = Text3d.LEFT - txt.setAlignment(align) - - if self.valignment == 1: - txt.setYoffset(0.0) - elif self.valignment == 2: - txt.setYoffset(- self.height * 0.5) - elif self.valignment == 3: - txt.setYoffset(- self.height) - - # move the object center to the text location - ob.loc = tuple(self.loc) - transform(self.extrusion, self.rotation, ob) - - # flip it and scale it to the text width - ob.SizeX *= self.height * self.width_factor * self.mirrorX - ob.SizeY *= self.height * self.mirrorY - if thic != 0.0: ob.SizeZ *= abs(thic) - return ob - - - -def set_thick(thickness, settings): - """Set thickness relative to settings variables. - - Set thickness relative to settings variables: - 'thick_on','thick_force','thick_min'. - Accepted also minus values of thickness - python trick: sign(x)=cmp(x,0) - """ - if settings.var['thick_force']: - if settings.var['thick_on']: - if abs(thickness) < settings.var['thick_min']: - thic = settings.var['thick_min'] * cmp(thickness,0) - else: thic = thickness - else: thic = settings.var['thick_min'] - else: - if settings.var['thick_on']: thic = thickness - else: thic = 0.0 - return thic - - - - -class Mtext: #----------------------------------------------------------------- - """Class for objects representing dxf MTEXT. - """ - - def __init__(self, obj): - """Expects an entity object of type mtext as input. - """ - if not obj.type == 'mtext': - raise TypeError, "Wrong type %s for mtext object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - - # required data - self.height = obj.get_type(40)[0] - self.width = obj.get_type(41)[0] - self.alignment = obj.get_type(71)[0] # alignment 1=TL, 2=TC, 3=TR, 4=ML, 5=MC, 6=MR, 7=BL, 8=BC, 9=BR - self.value = self.get_text(obj) # The text string value - - # optional data (with defaults) - self.space = getit(obj, 67, 0) - self.color_index = getit(obj, 62, BYLAYER) - self.rotation = getit(obj, 50, 0) # radians - - self.width_factor = getit(obj, 42, 1) # Scaling factor along local x axis - self.line_space = getit(obj, 44, 1) # percentage of default - - self.layer = getit(obj, 8, None) - self.loc = self.get_loc(obj) - self.extrusion = get_extrusion(obj) - - - def get_text(self, data): - """Reconstructs mtext data from dxf codes. - """ - primary = '' - secondary = [] - for item in data: - if item[0] == 1: # There should be only one primary... - primary = item[1] - elif item[0] == 3: # There may be any number of extra strings (in order) - secondary.append(item[1]) - if not primary: - #raise ValueError, "Empty Mtext Object!" - string = "Empty Mtext Object!" - if not secondary: - string = primary.replace(r'\P', '\n') - else: - string = ''.join(secondary)+primary - string = string.replace(r'\P', '\n') - return string - - - def get_loc(self, data): - """Gets location for a mtext type objects. - - Mtext objects have only one point indicating - """ - loc = [0, 0, 0] - loc[0] = getit(data, 10, None) - loc[1] = getit(data, 20, None) - loc[2] = getit(data, 30, 0.0) - return loc - - - def __repr__(self): - return "%s: layer - %s, value - %s" %(self.__class__.__name__, self.layer, self.value) - - - def draw(self, settings): - """for MTEXTs: generate Blender_geometry. - """ - # Now Create an object - obname = 'tm_%s' %self.layer # create object name from layer name - obname = obname[:MAX_NAMELENGTH] - txt = Text3d.New(obname) - ob = SCENE.objects.new(txt) # create a new text_object - - txt.setSize(1) - # Blender doesn't give access to its text object width currently - # only to the text3d's curve width... - #txt.setWidth(text.width/10) - txt.setLineSeparation(self.line_space) - txt.setExtrudeDepth(0.5) - txt.setText(self.value) - - # scale it to the text size - ob.SizeX = self.height * self.width_factor - ob.SizeY = self.height - ob.SizeZ = self.height - - # move the object center to the text location - ob.loc = tuple(self.loc) - transform(self.extrusion, self.rotation, ob) - - return ob - - -class Circle: #----------------------------------------------------------------- - """Class for objects representing dxf CIRCLEs. - """ - - def __init__(self, obj): - """Expects an entity object of type circle as input. - """ - if not obj.type == 'circle': - raise TypeError, "Wrong type %s for circle object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - - # required data - self.radius = obj.get_type(40)[0] - - # optional data (with defaults) - self.space = getit(obj, 67, 0) - self.thic = getit(obj, 39, 0) - self.color_index = getit(obj, 62, BYLAYER) - - self.layer = getit(obj, 8, None) - self.loc = self.get_loc(obj) - self.extrusion = get_extrusion(obj) - - - - def get_loc(self, data): - """Gets the center location for circle type objects. - - Circles have a single coord location. - """ - loc = [0, 0, 0] - loc[0] = getit(data, 10, None) - loc[1] = getit(data, 20, None) - loc[2] = getit(data, 30, 0.0) - return loc - - - - def __repr__(self): - return "%s: layer - %s, radius - %s" %(self.__class__.__name__, self.layer, self.radius) - - - def draw(self, settings): - """for CIRCLE: generate Blender_geometry. - """ - obname = 'ci_%s' %self.layer # create object name from layer name - obname = obname[:MAX_NAMELENGTH] - radius = self.radius - - thic = set_thick(self.thic, settings) - width = 0.0 - if settings.var['lines_as'] == 4: # as thin_box - thic = settings.var['thick_min'] - width = settings.var['width_min'] - if settings.var['lines_as'] == 3: # as thin cylinder - cyl_rad = 0.5 * settings.var['width_min'] - - if settings.var['lines_as'] == 5: # draw CIRCLE as curve ------------- - arc_res = settings.var['curve_arc'] - #arc_res = 3 - start, end = 0.0, 360.0 - VectorTriples = calcArc(None, radius, start, end, arc_res, True) - c = Curve.New(obname) # create new curve data - curve = c.appendNurb(BezTriple.New(VectorTriples[0])) - for p in VectorTriples[1:-1]: - curve.append(BezTriple.New(p)) - for point in curve: - point.handleTypes = [FREE, FREE] - point.radius = 1.0 - curve.flagU = 1 # 1 sets the curve cyclic=closed - if settings.var['fill_on']: - c.setFlag(6) # 2+4 set top and button caps - else: - c.setFlag(c.getFlag() & ~6) # dont set top and button caps - - c.setResolu(settings.var['curve_res']) - c.update() - - #--todo-----to check--------------------------- - ob = SCENE.objects.new(c) # create a new curve_object - ob.loc = tuple(self.loc) - if thic != 0.0: #hack: Blender<2.45 curve-extrusion - thic = thic * 0.5 - c.setExt1(1.0) # curve-extrusion accepts only (0.0 - 2.0) - ob.LocZ = thic + self.loc[2] - transform(self.extrusion, 0, ob) - if thic != 0.0: - ob.SizeZ *= abs(thic) - return ob - - else: # draw CIRCLE as mesh ----------------------------------------------- - if M_OBJ: obname, me, ob = makeNewObject() - else: - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - # set a number of segments in entire circle - arc_res = settings.var['arc_res'] * sqrt(radius) / sqrt(settings.var['arc_rad']) - start, end = 0.0 , 360.0 - verts = calcArc(None, radius, start, end, arc_res, False) - verts = verts[:-1] #list without last point/edge (cause by circle it is equal to the first point) - #print 'deb:circleDraw: verts:', verts #--------------- - - if thic != 0: - len1 = len(verts) - thic_verts = [] - thic_verts.extend([[point[0], point[1], point[2]+thic] for point in verts]) - if thic < 0.0: - thic_verts.extend(verts) - verts = thic_verts - else: - verts.extend(thic_verts) - faces = [] - f_band = [[num, num+1, num+len1+1, num+len1] for num in xrange(len1 - 1)] - #f_band = [[num, num+1, num+len1+1, num+len1] for num in xrange(len1)] - f_band.append([len1 - 1, 0, len1, len1 + len1 -1]) - faces = f_band - smooth_len = len(f_band) - if settings.var['fill_on']: - if thic < 0.0: - verts.append([0,0,thic]) #center of top side - verts.append([0,0,0]) #center of bottom side - else: - verts.append([0,0,0]) #center of bottom side - verts.append([0,0,thic]) #center of top side - center1 = len(verts)-2 - center2 = len(verts)-1 - f_bottom = [[num+1, num, center1] for num in xrange(len1 - 1)] - f_bottom.append([0, len1 - 1, center1]) - f_top = [[num+len1, num+1+len1, center2] for num in xrange(len1 - 1)] - f_top.append([len1-1+len1, 0+len1, center2]) - #print 'deb:circleDraw:verts:', verts #--------------- - faces = f_band + f_bottom + f_top - #print 'deb:circleDraw:faces:', faces #--------------- - me.verts.extend(verts) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - - if settings.var['meshSmooth_on']: # left and right side become smooth ---------------------- - for i in xrange(smooth_len): - me.faces[i].smooth = True - # each MeshSide becomes vertexGroup for easier material assignment --------------------- - if settings.var['vGroup_on'] and not M_OBJ: - # each MeshSide becomes vertexGroup for easier material assignment --------------------- - replace = Mesh.AssignModes.REPLACE #or .AssignModes.ADD - vg_band, vg_top, vg_bottom = [], [], [] - for v in f_band: vg_band.extend(v) - me.addVertGroup('side.band') ; me.assignVertsToGroup('side.band', vg_band, 1.0, replace) - - if settings.var['fill_on']: - for v in f_top: vg_top.extend(v) - for v in f_bottom: vg_bottom.extend(v) - me.addVertGroup('side.top') ; me.assignVertsToGroup('side.top', vg_top, 1.0, replace) - me.addVertGroup('side.bottom'); me.assignVertsToGroup('side.bottom',vg_bottom, 1.0, replace) - - else: # if thic == 0 - if settings.var['fill_on']: - len1 = len(verts) - verts.append([0,0,0]) #center of circle - center1 = len1 - faces = [] - faces.extend([[num, num+1, center1] for num in xrange(len1)]) - faces.append([len1-1, 0, center1]) - #print 'deb:circleDraw:verts:', verts #--------------- - #print 'deb:circleDraw:faces:', faces #--------------- - me.verts.extend(verts) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - else: - me.verts.extend(verts) # add vertices to mesh - edges = [[num, num+1] for num in xrange(len(verts))] - edges[-1][1] = 0 # it points the "new" last edge to the first vertex - me.edges.extend(edges) # add edges to the mesh - - ob.loc = tuple(self.loc) - transform(self.extrusion, 0, ob) - return ob - - -class Arc: #----------------------------------------------------------------- - """Class for objects representing dxf ARCs. - """ - - def __init__(self, obj): - """Expects an entity object of type arc as input. - """ - if not obj.type == 'arc': - raise TypeError, "Wrong type %s for arc object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - - # required data - self.radius = obj.get_type(40)[0] - self.start_angle = obj.get_type(50)[0] - self.end_angle = obj.get_type(51)[0] - - # optional data (with defaults) - self.space = getit(obj, 67, 0) - self.thic = getit(obj, 39, 0) - self.color_index = getit(obj, 62, BYLAYER) - - self.layer = getit(obj, 8, None) - self.loc = self.get_loc(obj) - self.extrusion = get_extrusion(obj) - #print 'deb:Arc__init__: center, radius, start, end:\n', self.loc, self.radius, self.start_angle, self.end_angle #--------- - - - - def get_loc(self, data): - """Gets the center location for arc type objects. - - Arcs have a single coord location. - """ - loc = [0, 0, 0] - loc[0] = getit(data, 10, None) - loc[1] = getit(data, 20, None) - loc[2] = getit(data, 30, 0.0) - return loc - - - - def __repr__(self): - return "%s: layer - %s, radius - %s" %(self.__class__.__name__, self.layer, self.radius) - - - def draw(self, settings): - """for ARC: generate Blender_geometry. - """ - obname = 'ar_%s' %self.layer # create object name from layer name - obname = obname[:MAX_NAMELENGTH] - - center = self.loc - radius = self.radius - start = self.start_angle - end = self.end_angle - #print 'deb:calcArcPoints:\n center, radius, start, end:\n', center, radius, start, end #--------- - thic = set_thick(self.thic, settings) - width = 0.0 - if settings.var['lines_as'] == 4: # as thin_box - thic = settings.var['thick_min'] - width = settings.var['width_min'] - if settings.var['lines_as'] == 3: # as thin cylinder - cyl_rad = 0.5 * settings.var['width_min'] - - if settings.var['lines_as'] == 5: # draw ARC as curve ------------- - arc_res = settings.var['curve_arc'] - triples = True - VectorTriples = calcArc(None, radius, start, end, arc_res, triples) - arc = Curve.New(obname) # create new curve data - curve = arc.appendNurb(BezTriple.New(VectorTriples[0])) - for p in VectorTriples[1:]: - curve.append(BezTriple.New(p)) - for point in curve: - point.handleTypes = [FREE, FREE] - point.radius = 1.0 - curve.flagU = 0 # 0 sets the curve not cyclic=open - arc.setResolu(settings.var['curve_res']) - - arc.update() #important for handles calculation - - ob = SCENE.objects.new(arc) # create a new curve_object - ob.loc = tuple(self.loc) - if thic != 0.0: #hack: Blender<2.45 curve-extrusion - thic = thic * 0.5 - arc.setExt1(1.0) # curve-extrusion: Blender2.45 accepts only (0.0 - 5.0) - ob.LocZ = thic + self.loc[2] - transform(self.extrusion, 0, ob) - if thic != 0.0: - ob.SizeZ *= abs(thic) - return ob - - else: # draw ARC as mesh -------------------- - if M_OBJ: obname, me, ob = makeNewObject() - else: - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - # set a number of segments in entire circle - arc_res = settings.var['arc_res'] * sqrt(radius) / sqrt(settings.var['arc_rad']) - - verts = calcArc(None, radius, start, end, arc_res, False) - #verts = [list(point) for point in verts] - len1 = len(verts) - #print 'deb:len1:', len1 #----------------------- - if width != 0: - radius_out = radius + (0.5 * width) - radius_in = radius - (0.5 * width) - if radius_in <= 0.0: - radius_in = settings.var['dist_min'] - #radius_in = 0.0 - verts_in = [] - verts_out = [] - for point in verts: - pointVec = Mathutils.Vector(point) - pointVec = pointVec.normalize() - verts_in.append(list(radius_in * pointVec)) #vertex inside - verts_out.append(list(radius_out * pointVec)) #vertex outside - verts = verts_in + verts_out - - #print 'deb:verts:', verts #--------------------- - if thic != 0: - thic_verts = [] - thic_verts.extend([[point[0], point[1], point[2]+thic] for point in verts]) - if thic < 0.0: - thic_verts.extend(verts) - verts = thic_verts - else: - verts.extend(thic_verts) - f_bottom = [[num, num+1, len1+num+1, len1+num] for num in xrange(len1-1)] - f_top = [[num, len1+num, len1+num+1, num+1] for num in xrange(len1+len1, len1+len1+len1-1)] - f_left = [[num, len1+len1+num, len1+len1+num+1, num+1] for num in xrange(len1-1)] - f_right = [[num, num+1, len1+len1+num+1, len1+len1+num] for num in xrange(len1, len1+len1-1)] - f_start = [[0, len1, len1+len1+len1, len1+len1]] - f_end = [[len1+len1-1, 0+len1-1, len1+len1+len1-1, len1+len1+len1+len1-1]] - faces = f_left + f_right + f_bottom + f_top + f_start + f_end - - me.verts.extend(verts) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - - if settings.var['meshSmooth_on']: # left and right side become smooth ---------------------- - smooth_len = len(f_left) + len(f_right) - for i in xrange(smooth_len): - me.faces[i].smooth = True - # each MeshSide becomes vertexGroup for easier material assignment --------------------- - if settings.var['vGroup_on'] and not M_OBJ: - # each MeshSide becomes vertexGroup for easier material assignment --------------------- - replace = Mesh.AssignModes.REPLACE #or .AssignModes.ADD - vg_left, vg_right, vg_top, vg_bottom = [], [], [], [] - for v in f_left: vg_left.extend(v) - for v in f_right: vg_right.extend(v) - for v in f_top: vg_top.extend(v) - for v in f_bottom: vg_bottom.extend(v) - me.addVertGroup('side.left') ; me.assignVertsToGroup('side.left', vg_left, 1.0, replace) - me.addVertGroup('side.right') ; me.assignVertsToGroup('side.right', vg_right, 1.0, replace) - me.addVertGroup('side.top') ; me.assignVertsToGroup('side.top', vg_top, 1.0, replace) - me.addVertGroup('side.bottom'); me.assignVertsToGroup('side.bottom',vg_bottom, 1.0, replace) - me.addVertGroup('side.start'); me.assignVertsToGroup('side.start', f_start[0], 1.0, replace) - me.addVertGroup('side.end') ; me.assignVertsToGroup('side.end', f_end[0], 1.0, replace) - - - else: # if thick=0 - draw only flat ring - faces = [[num, len1+num, len1+num+1, num+1] for num in xrange(len1 - 1)] - me.verts.extend(verts) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - - elif thic != 0: - thic_verts = [] - thic_verts.extend([[point[0], point[1], point[2]+thic] for point in verts]) - if thic < 0.0: - thic_verts.extend(verts) - verts = thic_verts - else: - verts.extend(thic_verts) - faces = [] - #print 'deb:len1:', len1 #----------------------- - #print 'deb:verts:', verts #--------------------- - faces = [[num, num+1, num+len1+1, num+len1] for num in xrange(len1 - 1)] - - me.verts.extend(verts) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - if settings.var['meshSmooth_on']: # left and right side become smooth ---------------------- - for i in xrange(len(faces)): - me.faces[i].smooth = True - - else: - edges = [[num, num+1] for num in xrange(len(verts)-1)] - me.verts.extend(verts) # add vertices to mesh - me.edges.extend(edges) # add edges to the mesh - - #me.update() - #ob = SCENE.objects.new(me) # create a new arc_object - #ob.link(me) - ob.loc = tuple(center) - #ob.loc = Mathutils.Vector(ob.loc) - transform(self.extrusion, 0, ob) - #ob.size = (1,1,1) - return ob - - -class BlockRecord: #----------------------------------------------------------------- - """Class for objects representing dxf block_records. - """ - - def __init__(self, obj): - """Expects an entity object of type block_record as input. - """ - if not obj.type == 'block_record': - raise TypeError, "Wrong type %s for block_record object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - - # required data - self.name = getit(obj, 2, None) - - # optional data (with defaults) - self.insertion_units = getit(obj, 70, None) - self.insert_units = getit(obj, 1070, None) - """code 1070 Einfuegeeinheiten: - 0 = Keine Einheiten; 1 = Zoll; 2 = Fuss; 3 = Meilen; 4 = Millimeter; - 5 = Zentimeter; 6 = Meter; 7 = Kilometer; 8 = Mikrozoll; - 9 = Mils; 10 = Yard; 11 = Angstrom; 12 = Nanometer; - 13 = Mikrons; 14 = Dezimeter; 15 = Dekameter; - 16 = Hektometer; 17 = Gigameter; 18 = Astronomische Einheiten; - 19 = Lichtjahre; 20 = Parsecs - """ - - - def __repr__(self): - return "%s: name - %s, insert units - %s" %(self.__class__.__name__, self.name, self.insertion_units) - - - - -class Block: #----------------------------------------------------------------- - """Class for objects representing dxf BLOCKs. - """ - - def __init__(self, obj): - """Expects an entity object of type block as input. - """ - if not obj.type == 'block': - raise TypeError, "Wrong type %s for block object!" %obj.type - - self.type = obj.type - self.name = obj.name - self.data = obj.data[:] - - # required data - self.flags = getit(obj, 70, 0) - self.anonim = self.flags & 1 #anonymous block generated by hatching, associative dimensioning, other - self.atrib = self.flags & 2 # has attribute definitions - self.xref = self.flags & 4 # is an external reference (xref) - self.xref_lay = self.flags & 8 # is an xref overlay - self.dep_ext = self.flags & 16 # is externally dependent - self.dep_res = self.flags & 32 # resolved external reference - self.xref_ext = self.flags & 64 # is a referenced external reference xref - #--todo--- if self.flag > 4: self.xref = True - - # optional data (with defaults) - self.path = getit(obj, 1, '') # Xref path name - self.discription = getit(obj, 4, '') - - self.entities = dxfObject('block_contents') #creates empty entities_container for this block - self.entities.data = objectify([ent for ent in obj.data if type(ent) != list]) - - self.layer = getit(obj, 8, None) - self.loc = self.get_loc(obj) - - #print 'deb:Block %s data:\n%s' %(self.name, self.data) #------------ - #print 'deb:Block %s self.entities.data:\n%s' %(self.name, self.entities.data) #------------ - - - - def get_loc(self, data): - """Gets the insert point of the block. - """ - loc = [0, 0, 0] - loc[0] = getit(data, 10, 0.0) # 10 = x - loc[1] = getit(data, 20, 0.0) # 20 = y - loc[2] = getit(data, 30, 0.0) # 30 = z - return loc - - - def __repr__(self): - return "%s: name - %s, description - %s, xref-path - %s" %(self.__class__.__name__, self.name, self.discription, self.path) - - - - -class Insert: #----------------------------------------------------------------- - """Class for objects representing dxf INSERTs. - """ - - def __init__(self, obj): - """Expects an entity object of type insert as input. - """ - if not obj.type == 'insert': - raise TypeError, "Wrong type %s for insert object!" %obj.type - self.type = obj.type - self.data = obj.data[:] - #print 'deb:Insert_init_ self.data:\n', self.data #----------- - - # required data - self.name = obj.get_type(2)[0] - - # optional data (with defaults) - self.rotation = getit(obj, 50, 0) - self.space = getit(obj, 67, 0) - self.color_index = getit(obj, 62, BYLAYER) - - self.layer = getit(obj, 8, None) - self.loc = self.get_loc(obj) - self.scale = self.get_scale(obj) - self.rows, self.columns = self.get_array(obj) - self.extrusion = get_extrusion(obj) - - #self.flags = getit(obj.data, 66, 0) # - #self.attrib = self.flags & 1 - - - def get_loc(self, data): - """Gets the origin location of the insert. - """ - loc = [0, 0, 0] - loc[0] = getit(data, 10, 0.0) - loc[1] = getit(data, 20, 0.0) - loc[2] = getit(data, 30, 0.0) - return loc - - - def get_scale(self, data): - """Gets the x/y/z scale factors of the insert. - """ - scale = [1, 1, 1] - scale[0] = getit(data, 41, 1.0) - scale[1] = getit(data, 42, 1.0) - scale[2] = getit(data, 43, 1.0) - return scale - - - def get_array(self, data): - """Returns the pair (row number, row spacing), (column number, column spacing). - """ - columns = getit(data, 70, 1) - rows = getit(data, 71, 1) - cspace = getit(data, 44, 0.0) - rspace = getit(data, 45, 0.0) - return (rows, rspace), (columns, cspace) - - - def get_target(self, data): - """Gets the origin location of the insert. - """ - loc = [0, 0, 0] - loc[0] = getit(data, 1011, 0.0) - loc[1] = getit(data, 1021, 0.0) - loc[2] = getit(data, 1031, 0.0) - return loc - - - def get_color(self, data): - """Gets the origin location of the insert. - """ - loc = [0, 0, 0] - loc[0] = getit(data, 1010, 0.0) - loc[1] = getit(data, 1020, 0.0) - loc[2] = getit(data, 1030, 0.0) - return loc - - - def get_ave_render(self, data): - """Gets the origin location of the insert. - """ - loc = [0, 0, 0] - loc[0] = getit(data, 1010, 0.0) - loc[1] = getit(data, 1020, 0.0) - loc[2] = getit(data, 1030, 0.0) - return loc - - - def __repr__(self): - return "%s: layer - %s, name - %s" %(self.__class__.__name__, self.layer, self.name) - - - def draw(self, settings, deltaloc): - """for INSERT(block): draw empty-marker for duplicated Blender_Group. - - Blocks are made of three objects: - the block_record in the tables section - the block in the blocks section - the insert object (one or more) in the entities section - block_record gives the insert units, - block provides the objects drawn in the block, - insert object gives the location/scale/rotation of the block instances. - """ - - name = self.name.lower() - if name == 'ave_render': - if settings.var['lights_on']: #if lights support activated - a_data = get_ave_data(self.data) - # AVE_RENDER objects: - # 7:'Pref', 0:'Full Opt', 0:'Quick Opt', 1:'Scanl Opt', 2:'Raytr Opt', 0:'RFile Opt' - # 0:'Fog Opt', 0:'BG Opt', 0:'SCENE1','','','','','','','','','', - # '','','','','','','','','','','','', - - if a_data.key == 'SCENE': # define set of lights as blender group - scene_lights = 1 - return - elif name == 'ave_global': - if settings.var['lights_on']: #if lights support activated - return - elif name == 'sh_spot': - if settings.var['lights_on']: #if lights support activated - obname = settings.blocknamesmap[self.name] - obname = 'sp_%s' %obname # create object name from block name - #obname = obname[:MAX_NAMELENGTH] - # blender: 'Lamp', 'Sun', 'Spot', 'Hemi', 'Area', or 'Photon' - li = Lamp.New('Spot', obname) - ob = SCENE.objects.new(li) - intensity = 2.0 #--todo-- ----------- - li.setEnergy(intensity) - target = self.get_target(self.data) - color = self.get_color(self.data) - li.R = color[0] - li.G = color[1] - li.B = color[2] - - ob.loc = tuple(self.loc) - transform(self.extrusion, 0, ob) - return ob - - elif name == 'overhead': - if settings.var['lights_on']: #if lights support activated - obname = settings.blocknamesmap[self.name] - obname = 'la_%s' %obname # create object name from block name - #obname = obname[:MAX_NAMELENGTH] - # blender: 'Lamp', 'Sun', 'Spot', 'Hemi', 'Area', or 'Photon' - li = Lamp.New('Lamp', obname) - ob = SCENE.objects.new(li) - intensity = 2.0 #--todo-- ----------- - li.setEnergy(intensity) - target = self.get_target(self.data) - color = self.get_color(self.data) - li.R = color[0] - li.G = color[1] - li.B = color[2] - - ob.loc = tuple(self.loc) - transform(self.extrusion, 0, ob) - return ob - - elif name == 'direct': - if settings.var['lights_on']: #if lights support activated - obname = settings.blocknamesmap[self.name] - obname = 'su_%s' %obname # create object name from block name - #obname = obname[:MAX_NAMELENGTH] - # blender: 'Lamp', 'Sun', 'Spot', 'Hemi', 'Area', or 'Photon' - li = Lamp.New('Sun', obname) - ob = SCENE.objects.new(li) - intensity = 2.0 #--todo-- ----------- - li.setEnergy(intensity) - color = self.get_color(self.data) - li.R = color[0] - li.G = color[1] - li.B = color[2] - - ob.loc = tuple(self.loc) - transform(self.extrusion, 0, ob) - return ob - - elif settings.drawTypes['insert']: #if insert_drawType activated - #print 'deb:draw. settings.blocknamesmap:', settings.blocknamesmap #-------------------- - obname = settings.blocknamesmap[self.name] - obname = 'in_%s' %obname # create object name from block name - #obname = obname[:MAX_NAMELENGTH] - - # if material BYBLOCK def needed: use as placeholder a mesh-vertex instead of empty - ob = SCENE.objects.new('Empty', obname) # create a new empty_object - empty_size = 1.0 * settings.var['g_scale'] - if empty_size < 0.01: empty_size = 0.01 #Blender limits (0.01-10.0) - elif empty_size > 10.0: empty_size = 10.0 - ob.drawSize = empty_size - - # get our block_def-group - block = settings.blocks(self.name) - ob.DupGroup = block - ob.enableDupGroup = True - - if block.name.startswith('xr_'): - ob.name = 'xb_' + ob.name[3:] - - #print 'deb:draw.block.deltaloc:', deltaloc #-------------------- - ob.loc = tuple(self.loc) - if deltaloc: - deltaloc = rotXY_Vec(self.rotation, deltaloc) - #print 'deb:draw.block.loc:', deltaloc #-------------------- - ob.loc = [ob.loc[0]+deltaloc[0], ob.loc[1]+deltaloc[1], ob.loc[2]+deltaloc[2]] - transform(self.extrusion, self.rotation, ob) - ob.size = tuple(self.scale) - return ob - - - - -class Ellipse: #----------------------------------------------------------------- - """Class for objects representing dxf ELLIPSEs. - """ - - def __init__(self, obj): - """Expects an entity object of type ellipse as input. - """ - if not obj.type == 'ellipse': - raise TypeError, "Wrong type %s for ellipse object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - - # required data - self.ratio = obj.get_type(40)[0] # Ratio of minor axis to major axis - self.start_angle = obj.get_type(41)[0] # in radians - self.end_angle = obj.get_type(42)[0] - - # optional data (with defaults) - self.space = getit(obj, 67, 0) - self.thic = getit(obj, 39, 0.0) - self.color_index = getit(obj, 62, BYLAYER) - - self.layer = getit(obj, 8, None) - self.loc = self.get_loc(obj) - self.major = self.get_major(obj) - self.extrusion = get_extrusion(obj) - - - def get_loc(self, data): - """Gets the center location for arc type objects. - - Arcs have a single coord location. - """ - loc = [0.0, 0.0, 0.0] - loc[0] = getit(data, 10, 0.0) - loc[1] = getit(data, 20, 0.0) - loc[2] = getit(data, 30, 0.0) - return loc - - - def get_major(self, data): - """Gets the major axis for ellipse type objects. - - The ellipse major axis defines the rotation of the ellipse and its radius. - """ - loc = [0.0, 0.0, 0.0] - loc[0] = getit(data, 11, 0.0) - loc[1] = getit(data, 21, 0.0) - loc[2] = getit(data, 31, 0.0) - return loc - - - def __repr__(self): - return "%s: layer - %s, radius - %s" %(self.__class__.__name__, self.layer, self.radius) - - - def draw(self, settings): - """for ELLIPSE: generate Blender_geometry. - """ - obname = 'el_%s' %self.layer # create object name from layer name - obname = obname[:MAX_NAMELENGTH] - - center = self.loc - start = degrees(self.start_angle) - end = degrees(self.end_angle) - if abs(end - 360.0) < 0.00001: end = 360.0 - ellipse_closed = False - if end - start == 360.0: ellipse_closed = True - - # rotation = Angle between major and WORLDX - # doesnt work, couse produces always positive value: rotation = Mathutils.AngleBetweenVecs(major, WORLDX) - if self.major[0] == 0: - rotation = 90.0 - if self.major[1] < 0: rotation += 180 - else: - rotation = degrees(atan(self.major[1] / self.major[0])) - if self.major[0] < 0: - rotation += 180.0 - - major = Mathutils.Vector(self.major) - #radius = sqrt(self.major[0]**2 + self.major[1]**2 + self.major[2]**2) - radius = major.length - #print 'deb:calcEllipse:\n center, radius, start, end:\n', center, radius, start, end #--------- - - thic = set_thick(self.thic, settings) - width = 0.0 - if settings.var['lines_as'] == 4: # as thin_box - thic = settings.var['thick_min'] - width = settings.var['width_min'] - elif settings.var['lines_as'] == 3: # as thin cylinder - cyl_rad = 0.5 * settings.var['width_min'] - - elif settings.var['lines_as'] == 5: # draw ELLIPSE as curve ------------- - arc_res = settings.var['curve_arc'] - triples = True - VectorTriples = calcArc(None, radius, start, end, arc_res, triples) - arc = Curve.New(obname) # create new curve data - curve = arc.appendNurb(BezTriple.New(VectorTriples[0])) - if ellipse_closed: - for p in VectorTriples[1:-1]: - curve.append(BezTriple.New(p)) - for point in curve: - point.handleTypes = [FREE, FREE] - point.radius = 1.0 - curve.flagU = 1 # 0 sets the curve not cyclic=open - if settings.var['fill_on']: - arc.setFlag(6) # 2+4 set top and button caps - else: - arc.setFlag(arc.getFlag() & ~6) # dont set top and button caps - else: - for p in VectorTriples[1:]: - curve.append(BezTriple.New(p)) - for point in curve: - point.handleTypes = [FREE, FREE] - point.radius = 1.0 - curve.flagU = 0 # 0 sets the curve not cyclic=open - - arc.setResolu(settings.var['curve_res']) - arc.update() #important for handles calculation - - ob = SCENE.objects.new(arc) # create a new curve_object - ob.loc = tuple(self.loc) - if thic != 0.0: #hack: Blender<2.45 curve-extrusion - thic = thic * 0.5 - arc.setExt1(1.0) # curve-extrusion: Blender2.45 accepts only (0.0 - 5.0) - ob.LocZ = thic + self.loc[2] - transform(self.extrusion, rotation, ob) - ob.SizeY *= self.ratio - if thic != 0.0: - ob.SizeZ *= abs(thic) - return ob - - - else: # draw ELLIPSE as mesh -------------------------------------- - if M_OBJ: obname, me, ob = makeNewObject() - else: - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - # set a number of segments in entire circle - arc_res = settings.var['arc_res'] * sqrt(radius) / sqrt(settings.var['arc_rad']) - - verts = calcArc(None, radius, start, end, arc_res, False) - #verts = [list(point) for point in verts] - len1 = len(verts) - #print 'deb:len1:', len1 #----------------------- - if width != 0: - radius_out = radius + (0.5 * width) - radius_in = radius - (0.5 * width) - if radius_in <= 0.0: - radius_in = settings.var['dist_min'] - #radius_in = 0.0 - verts_in = [] - verts_out = [] - for point in verts: - pointVec = Mathutils.Vector(point) - pointVec = pointVec.normalize() - verts_in.append(list(radius_in * pointVec)) #vertex inside - verts_out.append(list(radius_out * pointVec)) #vertex outside - verts = verts_in + verts_out - - #print 'deb:verts:', verts #--------------------- - if thic != 0: - thic_verts = [] - thic_verts.extend([[point[0], point[1], point[2]+thic] for point in verts]) - if thic < 0.0: - thic_verts.extend(verts) - verts = thic_verts - else: - verts.extend(thic_verts) - f_bottom = [[num, num+1, len1+num+1, len1+num] for num in xrange(len1-1)] - f_top = [[num, len1+num, len1+num+1, num+1] for num in xrange(len1+len1, len1+len1+len1-1)] - f_left = [[num, len1+len1+num, len1+len1+num+1, num+1] for num in xrange(len1-1)] - f_right = [[num, num+1, len1+len1+num+1, len1+len1+num] for num in xrange(len1, len1+len1-1)] - f_start = [[0, len1, len1+len1+len1, len1+len1]] - f_end = [[len1+len1-1, 0+len1-1, len1+len1+len1-1, len1+len1+len1+len1-1]] - faces = f_left + f_right + f_bottom + f_top + f_start + f_end - - me.verts.extend(verts) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - - if settings.var['meshSmooth_on']: # left and right side become smooth ---------------------- - smooth_len = len(f_left) + len(f_right) - for i in xrange(smooth_len): - me.faces[i].smooth = True - if settings.var['vGroup_on'] and not M_OBJ: - # each MeshSide becomes vertexGroup for easier material assignment --------------------- - replace = Mesh.AssignModes.REPLACE #or .AssignModes.ADD - vg_left, vg_right, vg_top, vg_bottom = [], [], [], [] - for v in f_left: vg_left.extend(v) - for v in f_right: vg_right.extend(v) - for v in f_top: vg_top.extend(v) - for v in f_bottom: vg_bottom.extend(v) - me.addVertGroup('side.left') ; me.assignVertsToGroup('side.left', vg_left, 1.0, replace) - me.addVertGroup('side.right') ; me.assignVertsToGroup('side.right', vg_right, 1.0, replace) - me.addVertGroup('side.top') ; me.assignVertsToGroup('side.top', vg_top, 1.0, replace) - me.addVertGroup('side.bottom'); me.assignVertsToGroup('side.bottom',vg_bottom, 1.0, replace) - me.addVertGroup('side.start'); me.assignVertsToGroup('side.start', f_start[0], 1.0, replace) - me.addVertGroup('side.end') ; me.assignVertsToGroup('side.end', f_end[0], 1.0, replace) - - - else: # if thick=0 - draw only flat ring - faces = [[num, len1+num, len1+num+1, num+1] for num in xrange(len1 - 1)] - me.verts.extend(verts) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - - elif thic != 0: - thic_verts = [] - thic_verts.extend([[point[0], point[1], point[2]+thic] for point in verts]) - if thic < 0.0: - thic_verts.extend(verts) - verts = thic_verts - else: - verts.extend(thic_verts) - faces = [] - #print 'deb:len1:', len1 #----------------------- - #print 'deb:verts:', verts #--------------------- - faces = [[num, num+1, num+len1+1, num+len1] for num in xrange(len1 - 1)] - - me.verts.extend(verts) # add vertices to mesh - me.faces.extend(faces) # add faces to the mesh - if settings.var['meshSmooth_on']: # left and right side become smooth ---------------------- - for i in xrange(len(faces)): - me.faces[i].smooth = True - - else: - edges = [[num, num+1] for num in xrange(len(verts)-1)] - me.verts.extend(verts) # add vertices to mesh - me.edges.extend(edges) # add edges to the mesh - - #print 'deb:calcEllipse transform rotation: ', rotation #--------- - ob.loc = tuple(center) - #old ob.SizeY = self.ratio - transform(self.extrusion, rotation, ob) - #old transform(self.extrusion, 0, ob) - ob.SizeY *= self.ratio - - return ob - - - -class Face: #----------------------------------------------------------------- - """Class for objects representing dxf 3DFACEs. - """ - - def __init__(self, obj): - """Expects an entity object of type 3dfaceplot as input. - """ - if not obj.type == '3dface': - raise TypeError, "Wrong type %s for 3dface object!" %obj.type - self.type = obj.type -# self.data = obj.data[:] - - # optional data (with defaults) - self.space = getit(obj, 67, 0) - self.color_index = getit(obj, 62, BYLAYER) - - self.layer = getit(obj, 8, None) - self.points = self.get_points(obj) - - - def get_points(self, data): - """Gets 3-4 points for a 3d face type object. - - Faces have three or optionally four verts. - """ - a = [0, 0, 0] - b = [0, 0, 0] - c = [0, 0, 0] - d = [0, 0, 0] - a[0] = getit(data, 10, None) # 10 = x - a[1] = getit(data, 20, None) # 20 = y - a[2] = getit(data, 30, 0.0) # 30 = z - b[0] = getit(data, 11, None) - b[1] = getit(data, 21, None) - b[2] = getit(data, 31, 0.0) - c[0] = getit(data, 12, None) - c[1] = getit(data, 22, None) - c[2] = getit(data, 32, 0.0) - out = [a,b,c] - - d[0] = getit(data, 13, None) - if d[0] != None: - d[1] = getit(data, 23, None) - d[2] = getit(data, 33, 0.0) - out.append(d) - - #if len(out) < 4: print '3dface with only 3 vertices:\n',a,b,c,d #----------------- - return out - - - def __repr__(self): - return "%s: layer - %s, points - %s" %(self.__class__.__name__, self.layer, self.points) - - - def draw(self, settings): - """for 3DFACE: generate Blender_geometry. - """ - # Generate the geometery - points = self.points - - global activObjectLayer - global activObjectName - #print 'deb:draw:face.ob IN activObjectName: ', activObjectName #--------------------- - - if M_OBJ: obname, me, ob = makeNewObject() - else: - if activObjectLayer == self.layer and settings.var['one_mesh_on']: - obname = activObjectName - #print 'deb:face.draw obname from activObjectName: ', obname #--------------------- - ob = getSceneChild(obname) # open an existing mesh_object - #ob = SCENE.getChildren(obname) # open an existing mesh_object - me = ob.getData(name_only=False, mesh=True) - else: - obname = 'fa_%s' %self.layer # create object name from layer name - obname = obname[:MAX_NAMELENGTH] - me = Mesh.New(obname) # create a new mesh - ob = SCENE.objects.new(me) # create a new mesh_object - activObjectName = ob.name - activObjectLayer = self.layer - #print ('deb:except. new face.ob+mesh:"%s" created!' %ob.name) #--------------------- - - #me = Mesh.Get(ob.name) # open objects mesh data - faces, edges = [], [] - n = len(me.verts) - if len(self.points) == 4: - faces = [[0+n,1+n,2+n,3+n]] - elif len(self.points) == 3: - faces = [[0+n,1+n,2+n]] - elif len(self.points) == 2: - edges = [[0+n,1+n]] - - me.verts.extend(points) # add vertices to mesh - if faces: me.faces.extend(faces) # add faces to the mesh - if edges: me.edges.extend(edges) # add faces to the mesh - if settings.var['vGroup_on'] and not M_OBJ: - # entities with the same color build one vertexGroup for easier material assignment --------------------- - ob.link(me) # link mesh to that object - vG_name = 'color_%s' %self.color_index - if edges: faces = edges - replace = Mesh.AssignModes.ADD #or .AssignModes.REPLACE or ADD - try: - me.assignVertsToGroup(vG_name, faces[0], 1.0, replace) - #print 'deb: existed vGroup:', vG_name #--------------------- - except: - me.addVertGroup(vG_name) - me.assignVertsToGroup(vG_name, faces[0], 1.0, replace) - #print 'deb: create new vGroup:', vG_name #-------------------- - - #print 'deb:draw:face.ob OUT activObjectName: ', activObjectName #--------------------- - return ob - - -#--------------------------------------------------------------------------------------- -# type to object maping (sorted-dictionary for f_obiectify ONLY!, format={'key':Class} ) -type_map = { - 'vport':Vport, - 'view':View, - 'layer':Layer, - 'block_record':BlockRecord, - 'block':Block, - 'insert':Insert, - 'point':Point, - '3dface':Face, - 'line':Line, -# 'mline':MLine, - 'polyline':Polyline, - 'lwpolyline':LWpolyline, - 'spline':Spline, -# 'region':Region, - 'trace':Solid, - 'solid':Solid, - 'text':Text, - 'mtext':Mtext, - 'circle':Circle, - 'ellipse':Ellipse, - 'arc':Arc -} - - - -def objectify(data): #----------------------------------------------------------------- - """Expects a section type object's data as input. - - Maps object data to the correct object type. - """ - #print 'deb:objectify start %%%%%%%%%%%' #--------------- - objects = [] # colector for finished objects - known_types = type_map.keys() # so we don't have to call foo.keys() every iteration - curves_on = GUI_A['curves_on'].val - index = 0 - while index < len(data): - item = data[index] - #print 'deb:objectify item: \n', item #------------ - if type(item) != list and item.type == 'table': - item.data = objectify(item.data) # tables have sub-objects - objects.append(item) - elif type(item) != list and item.type == 'polyline': #remi --todo----------- - #print 'deb:gosub Polyline\n' #------------- - pline = Polyline(item) - while 1: - index += 1 - item = data[index] - if item.type == 'vertex': - #print 'deb:objectify gosub Vertex--------' #------------- - v = Vertex(item) - if pline.spline: # if NURBSpline-curve - # then for Blender-mesh filter only additional_vertices - # OR - # then for Blender-curve filter only spline_control_vertices - if (v.spline and not curves_on) or (curves_on and v.spline_c): #correct for real NURBS-import - #if (v.spline and not curves_on) or (curves_on and not v.spline_c): #fake for Bezier-emulation of NURBS-import - pline.points.append(v) - elif pline.curved: # if Bezier-curve - # then for Blender-mesh filter only curve_additional_vertices - # OR - # then for Blender-curve filter curve_control_vertices - if not curves_on or (curves_on and not v.curved): - pline.points.append(v) - else: - pline.points.append(v) - elif item.type == 'seqend': - #print 'deb:objectify it is seqEND ---------\n' #------------- - break - else: - print "Error: non-vertex found before seqend!" - index -= 1 #so go back one step - break - objects.append(pline) - elif type(item) != list and item.type in ['block', 'insert']: - if not settings.var['block_nn'] and item.name.startswith('*X'): - #print 'deb:objectify item.type:"%s", item.name:"%s"' %(item.type, item.name) #------------ - pass - elif settings.var['blockFilter_on'] and not settings.accepted_block(item.name): - pass - else: - try: - objects.append(type_map[item.type](item)) - except TypeError: - pass - elif type(item) != list and item.type in known_types: - # proccess the object and append the resulting object - try: - objects.append(type_map[item.type](item)) - except TypeError: - pass - else: - #we will just let the data pass un-harrased - #objects.append(item) - pass - index += 1 - #print 'deb:objectify objects:\n', objects #------------ - #print 'deb:objectify END %%%%%%%%' #------------ - return objects - - - -class MatColors: #----------------------------------------------------------------- - """A smart container for dxf-color based materials. - - This class is a wrapper around a dictionary mapping dxf-color indicies to materials. - When called with a color_index - it returns a material corresponding to that index. - Behind the scenes it checks if that index is in its keys, and if not it creates - a new material. It then adds the new index:material pair to its dict and returns - the material. - """ - - def __init__(self): - """Expects a map - a dictionary mapping layer names to layers. - """ - #self.layersmap = layersmap # a dictionary of layername:layerobject - self.colMaterials = {} # a dictionary of color_index:blender_material - #print 'deb:init_MatColors argument.map: ', map #------------------ - - - def __call__(self, color=None): - """Return the material associated with color. - - If a layer name is provided, the color of that layer is used. - """ - if color == None: color = 256 # color 256=BYLAYER - if type(color) == str: # looking for color of LAYER named "color" - #--todo---bug with ARC from ARC-T0.DXF layer="T-3DARC-1"----- - #print 'deb:color is string:--------: ', color - #try: - #color = layersmap[color].color - #print 'deb:color=self.map[color].color:', color #------------------ - #except KeyError: - #layer = Layer(name=color, color=256, frozen=False) - #layersmap[color] = layer - #color = 0 - if color in layersmap.keys(): - color = layersmap[color].color - if color == 256: # color 256 = BYLAYER - #--todo-- should looking for color of LAYER - #if layersmap: color = layersmap[color].color - color = 3 - if color == 0: # color 0 = BYBLOCK - #--todo-- should looking for color of paret-BLOCK - #if layersmap: color = layersmap[color].color - color = 3 - color = abs(color) # cause the value could be nagative = means the layer is turned off - - if color not in self.colMaterials.keys(): - self.add(color) - return self.colMaterials[color] - - - def add(self, color): - """Create a new material 'ColorNr-N' using the provided color index-N. - """ - #global color_map #--todo-- has not to be global? - mat = Material.New('ColorNr-%s' %color) - mat.setRGBCol(color_map[color]) - #mat.mode |= Material.Modes.SHADELESS #--todo-- - #mat.mode |= Material.Modes.WIRE -# try: mat.setMode('Shadeless', 'Wire') #work-around for 2.45rc-bug -# except: pass - self.colMaterials[color] = mat - - - -class MatLayers: #----------------------------------------------------------------- - """A smart container for dxf-layer based materials. - - This class is a wrapper around a dictionary mapping dxf-layer names to materials. - When called with a layer name it returns a material corrisponding to that. - Behind the scenes it checks if that layername is in its keys, and if not it creates - a new material. It then adds the new layername:material pair to its dict and returns - the material. - """ - - def __init__(self): - """Expects a map - a dictionary mapping layer names to layers. - """ - #self.layersmap = layersmap # a dictionary of layername:layer - self.layMaterials = {} # a dictionary of layer_name:blender_material - #print 'deb:init_MatLayers argument.map: ', map #------------------ - - - def __call__(self, layername=None, color=None): - """Return the material associated with dxf-layer. - - If a dxf-layername is not provided, create a new material - """ - #global layernamesmap - layername_short = layername - if layername in layernamesmap.keys(): - layername_short = layernamesmap[layername] - colorlayername = layername_short - if color: colorlayername = str(color) + colorlayername - if colorlayername not in self.layMaterials.keys(): - self.add(layername, color, colorlayername) - return self.layMaterials[colorlayername] - - - def add(self, layername, color, colorlayername): - """Create a new material 'layername'. - """ - try: mat = Material.Get('L-%s' %colorlayername) - except: mat = Material.New('L-%s' %colorlayername) - #print 'deb:MatLayers material: ', mat #---------- - #global settings - #print 'deb:MatLayers material_from: ', settings.var['material_from'] #---------- - if settings.var['material_from'] == 3 and color: - if color == 0 or color == 256: mat_color = 3 - else: mat_color = color - elif layersmap and layername: - mat_color = layersmap[layername].color - else: mat_color = 3 - #print 'deb:MatLayers color: ', color #----------- - #print 'deb:MatLayers mat_color: ', mat_color #----------- - mat.setRGBCol(color_map[abs(mat_color)]) - #mat.mode |= Material.Modes.SHADELESS - #mat.mode |= Material.Modes.WIRE -# try: mat.setMode('Shadeless', 'Wire') #work-around for 2.45rc-bug -# except: pass - self.layMaterials[colorlayername] = mat - - - - -class Blocks: #----------------------------------------------------------------- - """A smart container for blocks. - - This class is a wrapper around a dictionary mapping block names to Blender data blocks. - When called with a name string it returns a block corresponding to that name. - Behind the scenes it checks if that name is in its keys, and if not it creates - a new data block. It then adds the new name:block_data pair to its dict and returns - the block. - """ - - def __init__(self, blocksmap, settings): - """Expects a dictionary mapping block_name:block_data. - """ - self.blocksmap = blocksmap #a dictionary mapping block_name:block_data - self.settings = settings - self.blocks = {} #container for blender groups representing blocks - - - def __call__(self, name=None): - """Return the data block associated with that block_name. - - If that name is not in its keys, it creates a new data block. - If no name is provided return entire self.blocks container. - """ - if name == None: - return self.blocks - if name not in self.blocks.keys(): - self.addBlock(name) - return self.blocks[name] - - - def addBlock(self, name): - """Create a new 'block group' for the block name. - """ - block = self.blocksmap[name] - prefix = 'bl' - if block.xref: prefix = 'xr' - blender_group = Group.New('%s_%s' %(prefix,name)) # Blender groupObject contains definition of BLOCK - block_def = [blender_group, block.loc] - self.settings.write("\nDrawing block:\'%s\' ..." % name) - - if block.xref: - obname = 'xr_%s' %name # create object name from xref block name - #obname = obname[:MAX_NAMELENGTH] - # if material BYBLOCK def needed: use as placeholder a mesh-vertex instead of empty - ob = SCENE.objects.new('Empty', obname) # create a new empty_object - empty_size = 1.0 * settings.var['g_scale'] - if empty_size < 0.01: empty_size = 0.01 #Blender limits (0.01-10.0) - elif empty_size > 10.0: empty_size = 10.0 - ob.drawSize = empty_size - ob.loc = tuple(block.loc) - ob.properties['xref_path'] = block.path - ob.layers = [19] - insertFlag=True; blockFlag=True - global oblist - oblist.append((ob, insertFlag, blockFlag)) - else: - if M_OBJ: - car_end() - car_start() - drawEntities(block.entities, self.settings, block_def) - if M_OBJ: car_end() - self.settings.write("Drawing block:\'%s\' done!" %name) - self.blocks[name] = blender_group - - - - - -class Settings: #----------------------------------------------------------------- - """A container for all the import settings and objects used by the draw functions. - - 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 draw 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['layerFilter_on'] = False #deb:remi------------ - self.acceptedLayers = ['3', - '0' - ] - - self.var['groupFilter_on'] = False #deb:remi------------ - self.acceptedLayers = ['3', - '0' - ] - - #self.var['blockFilter_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['line'] - self.drawTypes['circle'] = self.drawTypes['line'] - self.drawTypes['ellipse'] = self.drawTypes['line'] - self.drawTypes['trace'] = self.drawTypes['solid'] - self.drawTypes['insert'] = self.drawTypes['block'] - #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.var['thick_min'] = self.var['thick_min'] / self.var['g_scale'] - self.var['width_min'] = self.var['width_min'] / self.var['g_scale'] - self.var['arc_rad'] = self.var['arc_rad'] / self.var['g_scale'] - - self.g_origin = Mathutils.Vector(self.var['g_originX'], self.var['g_originY'], self.var['g_originZ']) - - # First sort out all the section_items - sections = dict([(item.name, item) for item in drawing.data]) - - # The section:header may be omited - if 'header' in sections.keys(): - self.write("found section:header") - else: - self.write("File contains no section:header!") - - if self.var['optimization'] == 0: self.var['one_mesh_on'] = 0 - # The section:tables may be partialy or completely missing. - self.layersTable = False - self.colMaterials = MatColors() #A container for dxf-color based materials - self.layMaterials = MatLayers() #A container for dxf-layer based materials - #self.collayMaterials = MatColLayers({}) #A container for dxf-color+layer based materials - global layersmap, layernamesmap - layersmap, layernamesmap = {}, {} - if 'tables' in sections.keys(): - self.write("found section:tables") - views, vports, layers = False, False, False - for table in drawing.tables.data: - if table.name == 'layer': - self.write("found table:layers") - layers = table - elif table.name == 'view': - print "found table:view" - views = table - elif table.name == 'vport': - print "found table:vport" - vports = table - if layers: #---------------------------------- - # Read the layers table and get the layer colors - layersmap, layernamesmap = getLayersmap(layers) - #self.colMaterials = MatColors() - #self.layMaterials = MatLayers() - else: - self.write("File contains no table:layers!") - - - if views: #---------------------------------- - if self.var['views_on']: - for item in views.data: - if type(item) != list and item.type == 'view': - #print 'deb:settings_valid views dir(item)=', dir(item) #------------- - #print 'deb:settings_valid views item=', item #------------- - ob = item.draw(self) - #viewsmap[item.name] = [item.length] - #--todo-- add to obj_list for global.Scaling - insertFlag, blockFlag = False, False - oblist.append((ob, insertFlag, blockFlag)) - - else: - self.write("File contains no table:views!") - - - if vports: #---------------------------------- - if self.var['views_on']: - for item in vports.data: - if type(item) != list and item.type == 'vport': - #print 'deb:settings_valid views dir(item)=', dir(item) #------------- - #print 'deb:settings_valid views item=', item #------------- - ob = item.draw(self) - #viewsmap[item.name] = [item.length] - #--todo-- add to obj_list for global.Scaling - insertFlag, blockFlag = False, False - oblist.append((ob, insertFlag, blockFlag)) - else: - self.write("File contains no table:vports!") - - - else: - self.write("File contains no section:tables!") - self.write("File contains no table:layers!") - - - # The section:blocks may be omited - if 'blocks' in sections.keys(): - self.write("found section:blocks") - # Read the block definitions and build our block object - if self.drawTypes['insert']: #if support for entity type 'Insert' is activated - #Build a dictionary of blockname:block_data pairs - blocksmap, obj_number = getBlocksmap(drawing, layersmap, self.var['layFrozen_on']) - self.obj_number += obj_number - self.blocknamesmap = getBlocknamesmap(blocksmap) - self.blocks = Blocks(blocksmap, self) # initiates container for blocks_data - self.usedBlocks = blocksmap.keys() - #print 'deb:settings_valid self.usedBlocks', self.usedBlocks #---------- - else: - self.write("ignored, because support for BLOCKs is turn off!") - #print 'deb:settings_valid self.obj_number', self.obj_number #---------- - else: - self.write("File contains no section:blocks!") - self.drawTypes['insert'] = False - - # The section:entities - if 'entities' in sections.keys(): - self.write("found section:entities") - self.obj_number += len(drawing.entities.data) - self.obj_number = 1.0 / self.obj_number - - - def accepted_block(self, name): - if name not in self.usedBlocks: return False - if name in self.unwantedBlocks: return False - elif name in self.acceptedBlocks: return True - #elif (name.find('*X')+1): return False - #elif name.startswith('3'): return True - #elif name.endswith('H'): return False - return True - - - 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 #----------------------- - - def layer_isOff(self, layername): # no more used ------- - """Given a layer name, and return its visible status. - """ - # if layer is off then color_index is negative - if layersmap and layersmap[layername].color < 0: return True - #print 'deb:layer_isOff: layer is ON' #--------------- - return False - - - def layer_isFrozen(self, layername): # no more used ------- - """Given a layer name, and return its frozen status. - """ - if layersmap and layersmap[layername].frozen: return True - #print 'deb:layer_isFrozen: layer is not FROZEN' #--------------- - return False - - - -def analyzeDXF(dxfFile): #--------------------------------------- - """list statistics about LAYER and BLOCK dependences into textfile.INF - - """ - Window.WaitCursor(True) # Let the user know we are thinking - print 'reading DXF file: %s.' % dxfFile - time1 = sys.time() #time marker1 - drawing = readDXF(dxfFile, objectify) - print 'finish reading in %.4f sec.' % (sys.time()-time1) - - # First sort out all the section_items - sections = dict([(item.name, item) for item in drawing.data]) - - # The section:header may be omited - if 'header' in sections.keys(): print "found section:header" - else: print "File contains no section:header!" - - # The section:tables may be partialy or completely missing. - layersTable = False - global layersmap - layersmap = {} - viewsmap = {} - vportsmap = {} - layersmap_str = '#File contains no table:layers!' - viewsmap_str = '#File contains no table:views!' - vportsmap_str = '#File contains no table:vports!' - if 'tables' in sections.keys(): - print "found section:tables" - views, vports, layers = False, False, False - for table in drawing.tables.data: - if table.name == 'layer': - print "found table:layers" - layers = table - elif table.name == 'view': - print "found table:view" - views = table - elif table.name == 'vport': - print "found table:vport" - vports = table - if layers: #---------------------------------- - for item in layers.data: - if type(item) != list and item.type == 'layer': - #print dir(item) - layersmap[item.name] = [item.color, item.frozen] - #print 'deb:analyzeDXF: layersmap=' , layersmap #------------- - layersmap_str = '#list of LAYERs: name, color, frozen_status ---------------------------\n' - key_list = layersmap.keys() - key_list.sort() - for key in key_list: - #for layer_name, layer_data in layersmap.iteritems(): - layer_name, layer_data = key, layersmap[key] - layer_str = '\'%s\': col=%s' %(layer_name,layer_data[0])#------------- - if layer_data[1]: layer_str += ', frozen' - layersmap_str += layer_str + '\n' - #print 'deb:analyzeDXF: layersmap_str=\n' , layersmap_str #------------- - else: - print "File contains no table:layers!" - - if views: #---------------------------------- - for item in views.data: - if type(item) != list and item.type == 'view': - #print dir(item) - viewsmap[item.name] = [item.length] - #print 'deb:analyzeDXF: viewsmap=' , viewsmap #------------- - viewsmap_str = '#list of VIEWs: name, focus_length ------------------------------------\n' - key_list = viewsmap.keys() - key_list.sort() - for key in key_list: - #for view_name, view_data in viewsmap.iteritems(): - view_name, view_data = key, viewsmap[key] - view_str = '\'%s\': length=%s' %(view_name,view_data[0])#------------- - #if view_data[1]: view_str += ', something' - viewsmap_str += view_str + '\n' - #print 'deb:analyzeDXF: layersmap_str=\n' , layersmap_str #------------- - else: - print "File contains no table:views!" - - if vports: #---------------------------------- - for item in vports.data: - if type(item) != list and item.type == 'vport': - #print dir(item) - vportsmap[item.name] = [item.length] - #print 'deb:analyzeDXF: vportsmap=' , vportsmap #------------- - vportsmap_str = '#list of VPORTs: name, focus_length -----------------------------------\n' - key_list = vportsmap.keys() - key_list.sort() - for key in key_list: - #for vport_name, vport_data in vportsmap.iteritems(): - vport_name, vport_data = key, vportsmap[key] - vport_str = '\'%s\': length=%s' %(vport_name,vport_data[0])#------------- - #if vport_data[1]: vport_str += ', something' - vportsmap_str += vport_str + '\n' - #print 'deb:analyzeDXF: vportsmap_str=\n' , vportsmap_str #------------- - else: - print "File contains no table:vports!" - - else: - print "File contains no section:tables!" - print "File contains no tables:layers,views,vports!" - - # The section:blocks may be omited - if 'blocks' in sections.keys(): - print "found section:blocks" - blocksmap = {} - for item in drawing.blocks.data: - #print 'deb:getBlocksmap item=' ,item #-------- - #print 'deb:getBlocksmap item.entities=' ,item.entities #-------- - #print 'deb:getBlocksmap item.entities.data=' ,item.entities.data #-------- - if type(item) != list and item.type == 'block': - xref = False - if item.xref: xref = True - childList = [] - used = False - for item2 in item.entities.data: - if type(item2) != list and item2.type == 'insert': - #print 'deb:getBlocksmap dir(item2)=', dir(item2) #---------- - item2str = [item2.name, item2.layer, item2.color_index, item2.scale, item2.space] - childList.append(item2str) - try: blocksmap[item.name] = [used, childList, xref] - except KeyError: print 'Cannot map "%s" - "%s" as Block!' %(item.name, item) - #print 'deb:analyzeDXF: blocksmap=' , blocksmap #------------- - - for item2 in drawing.entities.data: - if type(item2) != list and item2.type == 'insert': - if item2.name in blocksmap.keys(): - if not layersmap or (layersmap and not layersmap[item2.layer][1]): #if insert_layer is not frozen - blocksmap[item2.name][0] = True # marked as world used BLOCK - - key_list = blocksmap.keys() - key_list.reverse() - for key in key_list: - if blocksmap[key][0]: #if used - for child in blocksmap[key][1]: - if not layersmap or (layersmap and not layersmap[child[1]][1]): #if insert_layer is not frozen - blocksmap[child[0]][0] = True # marked as used BLOCK - - blocksmap_str = '#list of BLOCKs: name:(unused)(xref) -[child_name, layer, color, scale, space]-------\n' - key_list = blocksmap.keys() - key_list.sort() - for key in key_list: - #for block_name, block_data in blocksmap.iteritems(): - block_name, block_data = key, blocksmap[key] - block_str = '\'%s\': ' %(block_name) #------------- - used = '(unused)' - if block_data[0]: used = '' -# else: used = '(unused)' - xref = '' - if block_data[2]: xref = '(xref)' - blocksmap_str += block_str + used + xref +'\n' - if block_data: - for block_item in block_data[1]: - block_data_str = ' - %s\n' %block_item - blocksmap_str += block_data_str - #print 'deb:analyzeDXF: blocksmap_str=\n' , blocksmap_str #------------- - else: - blocksmap_str = '#File contains no section:blocks!' - print "File contains no section:blocks!" - - Window.WaitCursor(False) - output_str = '%s\n%s\n%s\n%s' %(viewsmap_str, vportsmap_str, layersmap_str, blocksmap_str) - infFile = dxfFile[:-4] + '_DXF.INF' # replace last char:'.dxf' with '_DXF.inf' - try: - f = file(infFile, 'w') - f.write(INFFILE_HEADER + '\n# this is a comment line\n\n') - f.write(output_str) - f.close() - Draw.PupMenu('DXF importer: report saved in INF-file:%t|' + '\'%s\'' %infFile) - except: - Draw.PupMenu('DXF importer: ERROR by writing report in INF-file:%t|' + '\'%s\'' %infFile) - #finally: f.close() - - - - -def main(dxfFile): #---------------#############################----------- - #print 'deb:filename:', filename #-------------- - global SCENE - global oblist - editmode = Window.EditMode() # are we in edit mode? If so ... - if editmode: - Window.EditMode(0) # leave edit mode before - - #SCENE = bpy.data.scenes.active - #SCENE.objects.selected = [] # deselect all - - global cur_COUNTER #counter for progress_bar - cur_COUNTER = 0 - - #try: - if 1: - #print "Getting settings..." - global GUI_A, GUI_B, g_scale_as - if not GUI_A['g_scale_on'].val: - GUI_A['g_scale'].val = 1.0 - - keywords = {} - drawTypes = {} - for k, v in GUI_A.iteritems(): - keywords[k] = v.val - for k, v in GUI_B.iteritems(): - drawTypes[k] = v.val - #print 'deb:startUInew keywords: ', keywords #-------------- - #print 'deb:startUInew drawTypes: ', drawTypes #-------------- - - # The settings object controls how dxf entities are drawn - settings.update(keywords, drawTypes) - #print 'deb:settings.var:\n', settings.var #----------------------- - - if not settings: - #Draw.PupMenu('DXF importer: EXIT!%t') - #print '\nDXF Import: terminated by user!' - print '\nDXF Import: terminated, cause settings failure!' - Window.WaitCursor(False) - if editmode: Window.EditMode(1) # and put things back how we fond them - return None - - #no more used dxfFile = dxfFileName.val - #print 'deb: dxfFile file: ', dxfFile #---------------------- - if dxfFile.lower().endswith('.dxf') and sys.exists(dxfFile): - Window.WaitCursor(True) # Let the user know we are thinking - print 'reading file: %s.' % dxfFile - time1 = sys.time() #time marker1 - drawing = readDXF(dxfFile, objectify) - print 'reading finished in %.4f sec.' % (sys.time()-time1) - Window.WaitCursor(False) - elif dxfFile.lower().endswith('.dwg') and sys.exists(dxfFile): - if not extCONV_OK: - Draw.PupMenu(extCONV_TEXT) - Window.WaitCursor(False) - if editmode: Window.EditMode(1) # and put things back how we fond them - return None - else: - Window.WaitCursor(True) # Let the user know we are thinking - #todo: issue: in DConvertCon.exe the output filename is fixed to dwg_name.dxf - - if 0: # works only for Windows - dwgTemp = 'temp_01.dwg' - dxfTemp = 'temp_01.dxf' - os.system('copy %s %s' %(dxfFile,dwgTemp)) - else: - dwgTemp = dxfFile - dxfTemp = dxfFile[:-3]+'dxf' - #print 'temp. converting: %s\n to: %s' %(dxfFile, dxfTemp) - #os.system('%s %s -acad11 -dxf' %(extCONV_PATH, dxfFile)) - os.system('%s %s -dxf' %(extCONV_PATH, dwgTemp)) - #os.system('%s %s -dxf' %(extCONV_PATH, dxfFile_temp)) - if sys.exists(dxfTemp): - print 'reading file: %s.' % dxfTemp - time1 = sys.time() #time marker1 - drawing = readDXF(dxfTemp, objectify) - #os.remove(dwgTemp) - os.remove(dxfTemp) # clean up - print 'reading finished in %.4f sec.' % (sys.time()-time1) - Window.WaitCursor(False) - else: - if UI_MODE: Draw.PupMenu('DWG importer: nothing imported!%t|No valid DXF-representation found!') - print 'DWG importer: nothing imported. No valid DXF-representation found.' - Window.WaitCursor(False) - if editmode: Window.EditMode(1) # and put things back how we fond them - return None - else: - if UI_MODE: Draw.PupMenu('DXF importer: Alert!%t| no valid DXF-file selected!') - print "DXF importer: Alert! - no valid DXF-file selected." - Window.WaitCursor(False) - if editmode: Window.EditMode(1) # and put things back how we fond them - return None - - # Draw all the know entity types in the current scene - oblist = [] # a list of all created AND linked objects for final f_globalScale - time2 = sys.time() #time marker2 - - Window.WaitCursor(True) # Let the user know we are thinking - settings.write("\n\nDrawing entities...") - - settings.validate(drawing) - - global activObjectLayer, activObjectName - activObjectLayer, activObjectName = None, None - - if M_OBJ: car_init() - - drawEntities(drawing.entities, settings) - - #print 'deb:drawEntities after: oblist:', oblist #----------------------- - if M_OBJ: car_end() - if oblist: # and settings.var['g_scale'] != 1: - globalScale(oblist, settings.var['g_scale']) - - # Set visibility for all layers on all View3d - #Window.ViewLayers([i+1 for i in range(18)]) # for 2.45 - SCENE.setLayers([i+1 for i in range(18)]) - SCENE.update(1) - SCENE.objects.selected = [i[0] for i in oblist] #select only the imported objects - #SCENE.objects.selected = SCENE.objects #select all objects in current scene - Blender.Redraw() - - time_text = sys.time() - time2 - Window.WaitCursor(False) - if settings.var['paper_space_on']: space = 'from paper space' - else: space = 'from model space' - ob_len = len(oblist) - message = ' %s objects imported %s in %.4f sec. -----DONE-----' % (ob_len, space, time_text) - settings.progress(1.0/settings.obj_number, 'DXF import done!') - print message - #settings.write(message) - if UI_MODE: Draw.PupMenu('DXF importer: Done!|finished in %.4f sec.' % time_text) - - #finally: - # restore state even if things didn't work - #print 'deb:drawEntities finally!' #----------------------- - Window.WaitCursor(False) - if editmode: Window.EditMode(1) # and put things back how we fond them - - - -def getOCS(az): #----------------------------------------------------------------- - """An implimentation of the Arbitrary Axis Algorithm. - """ - #decide if we need to transform our coords - #if az[0] == 0 and az[1] == 0: - if abs(az[0]) < 0.00001 and abs(az[1]) < 0.00001: - if az[2] > 0.0: - return False - elif az[2] < 0.0: - ax = Mathutils.Vector(-1.0, 0, 0) - ay = Mathutils.Vector(0, 1.0, 0) - az = Mathutils.Vector(0, 0, -1.0) - return ax, ay, az - - az = Mathutils.Vector(az) - - cap = 0.015625 # square polar cap value (1/64.0) - if abs(az.x) < cap and abs(az.y) < cap: - ax = M_CrossVecs(WORLDY,az) - else: - ax = M_CrossVecs(WORLDZ,az) - ax = ax.normalize() - ay = M_CrossVecs(az, ax) - ay = ay.normalize() - return ax, ay, az - - - -def transform(normal, rotation, obj): #-------------------------------------------- - """Use the calculated ocs to determine the objects location/orientation in space. - - Quote from dxf docs: - The elevation value stored with an entity and output in DXF files is a sum - of the Z-coordinate difference between the UCS XY plane and the OCS XY - plane, and the elevation value that the user specified at the time the entity - was drawn. - """ - ma = Mathutils.Matrix([1,0,0],[0,1,0],[0,0,1]) - o = Mathutils.Vector(obj.loc) - ocs = getOCS(normal) - if ocs: - ma = Mathutils.Matrix(ocs[0], ocs[1], ocs[2]) - o = ma.invert() * o - ma = Mathutils.Matrix(ocs[0], ocs[1], ocs[2]) - - if rotation != 0: - g = radians(-rotation) - rmat = Mathutils.Matrix([cos(g), -sin(g), 0], [sin(g), cos(g), 0], [0, 0, 1]) - ma = rmat * ma - - obj.setMatrix(ma) - obj.loc = o - #print 'deb:new obj.matrix:\n', obj.getMatrix() #-------------------- - - - -def rotXY_Vec(rotation, vec): #---------------------------------------------------- - """Rotate vector vec in XY-plane. vec must be in radians - """ - if rotation != 0: - o = Mathutils.Vector(vec) - g = radians(-rotation) - vec = o * Mathutils.Matrix([cos(g), -sin(g), 0], [sin(g), cos(g), 0], [0, 0, 1]) - return vec - - - -def getLayersmap(dxflayers): #------------------------------------------------------ - """Build two dictionaries: 1.layername:layer object, and 2.layername:layername_short - gets set of layers from TABLES SECTION LAYERS - """ - layersmap = {} - layernamesmap = {} - for item in dxflayers.data: - if type(item) != list and item.type == 'layer': - layersmap[item.name] = item - layername_short = item.name[:MAX_NAMELENGTH-1] - i = 0 #sufix for layernames cause Blender-objectnames-limits - while layername_short in layernamesmap.keys(): - i += 1 - suffix = str(i) #--todo--set zero-leading number format - layername_short = layername_short[:-2] + suffix - layernamesmap[item.name] = layername_short - - #print 'deb:getLayersmap layersmap:\n', layersmap #------------ - #print 'deb:getLayersmap layernamesmap:\n', layernamesmap #------------ - return layersmap, layernamesmap - - - -def getBlocksmap(drawing, layersmap, layFrozen_on=False): #-------------------------------------------------------- - """Build a dictionary of blockname:block_data pairs - """ - usedblocks = {} - for item in drawing.blocks.data: - #print 'deb:getBlocksmap item=%s\n i.entities=%s\n i.data=%s' %(item,item.entities,item.entities.data) - if type(item) != list and item.type == 'block': - childList = [] - used = False - for item2 in item.entities.data: - if type(item2) != list and item2.type == 'insert': - #print 'deb:getBlocksmap dir(item2)=', dir(item2) #---------- - item2str = [item2.name, item2.layer] - childList.append(item2str) - try: usedblocks[item.name] = [used, childList] - except KeyError: print 'Cannot find "%s" Block!' %(item.name) - #print 'deb:getBlocksmap: usedblocks=' , usedblocks #------------- - #print 'deb:getBlocksmap: layersmap=' , layersmap #------------- - - for item in drawing.entities.data: - if type(item) != list and item.type == 'insert': - if not layersmap or (not layersmap[item.layer].frozen or layFrozen_on): #if insert_layer is not frozen - try: usedblocks[item.name][0] = True - except KeyError: print 'Cannot find "%s" Block!' %(item.name) - - key_list = usedblocks.keys() - key_list.reverse() - for key in key_list: - if usedblocks[key][0]: #if parent used, then set used also all child blocks - for child in usedblocks[key][1]: - if not layersmap or (layersmap and not layersmap[child[1]].frozen): #if insert_layer is not frozen - try: usedblocks[child[0]][0] = True # marked as used BLOCK - except KeyError: print 'Cannot find "%s" Block!' %(child[0]) - - usedblocks = [i for i in usedblocks.keys() if usedblocks[i][0]] - #print 'deb:getBlocksmap: usedblocks=' , usedblocks #------------- - obj_number = 0 - blocksmap = {} - for item in drawing.blocks.data: - if type(item) != list and item.type == 'block' and item.name in usedblocks: - #if item.name.startswith('*X'): #--todo-- - obj_number += len(item.entities.data) - try: blocksmap[item.name] = item - except KeyError: print 'Cannot map "%s" - "%s" as Block!' %(item.name, item) - - - #print 'deb:getBlocksmap: blocksmap:\n', blocksmap #------------ - return blocksmap, obj_number - - -def getBlocknamesmap(blocksmap): #-------------------------------------------------------- - """Build a dictionary of blockname:blockname_short pairs - """ - #print 'deb:getBlocknamesmap blocksmap:\n', blocksmap #------------ - blocknamesmap = {} - for n in blocksmap.keys(): - blockname_short = n[:MAX_NAMELENGTH-1] - i = 0 #sufix for blockname cause Blender-objectnamelength-limit - while blockname_short in blocknamesmap.keys(): - i += 1 - suffix = str(i) - blockname_short = blockname_short[:-2] + suffix - blocknamesmap[n] = blockname_short - #print 'deb:getBlocknamesmap blocknamesmap:\n', blocknamesmap #------------ - return blocknamesmap - - -def drawEntities(entities, settings, block_def=None): #---------------------------------------- - """Draw every kind of thing in the entity list. - - If provided 'block_def': the entities are to be added to the Blender 'group'. - """ - for _type in type_map.keys(): - #print 'deb:drawEntities_type:', _type #------------------ - # for each known type get a list of that type and call the associated draw function - entities_type = entities.get_type(_type) - if entities_type: drawer(_type, entities_type, settings, block_def) - - -def drawer(_type, entities, settings, block_def): #------------------------------------------ - """Call with a list of entities and a settings object to generate Blender geometry. - - If 'block_def': the entities are to be added to the Blender 'group'. - """ - global layersmap, layersmapshort - #print 'deb:drawer _type, entities:\n ', _type, entities #----------------------- - - if entities: - # Break out early if settings says we aren't drawing the current dxf-type - global cur_COUNTER #counter for progress_bar - group = None - #print 'deb:drawer.check:_type: ', _type #-------------------- - if _type == '3dface':_type = 'face' # hack, while python_variable_name can not beginn with a nummber - if not settings.drawTypes[_type] or _type == 'block_record': - message = 'Skipping dxf\'%ss\' entities' %_type - settings.write(message, True) - cur_COUNTER += len(entities) - settings.progress(cur_COUNTER, message) - return - #print 'deb:drawer.todo:_type:', _type #----------------------- - #print 'deb:drawer entities:\n ', entities #----------------------- - - len_temp = len(entities) - # filtering only model-space enitities (no paper-space enitities) - if settings.var['paper_space_on']: - entities = [entity for entity in entities if entity.space != 0] - else: - entities = [entity for entity in entities if entity.space == 0] - - # filtering only objects with color from acceptedColorsList - if settings.var['colorFilter_on']: - entities = [entity for entity in entities if entity.color in settings.acceptedColors] - - # filtering only objects on layers from acceptedLayersList - if settings.var['layerFilter_on']: - #entities = [entity for entity in entities if entity.layer[0] in ['M','3','0'] and not entity.layer.endswith('H')] - entities = [entity for entity in entities if entity.layer in settings.acceptedLayers] - - # patch for incomplete layer table in HL2-DXF-files - if layersmap: - for entity in entities: - oblayer = entity.layer - if oblayer not in layersmap.keys(): - layer_obj = Layer(None, name=oblayer) - layersmap[oblayer] = layer_obj - layername_short = oblayer[:MAX_NAMELENGTH-1] - i = 0 #sufix for layernames cause Blender-objectnames-limits - while layername_short in layernamesmap.keys(): - i += 1 - suffix = str(i) #--todo--set zero-leading number format - layername_short = layername_short[:-2] + suffix - layernamesmap[oblayer] = layername_short - - # filtering only objects on not-frozen layers - if layersmap and not settings.var['layFrozen_on']: - entities = [entity for entity in entities if not layersmap[entity.layer].frozen] - - global activObjectLayer, activObjectName - activObjectLayer = '' - activObjectName = '' - - message = "Drawing dxf \'%ss\'..." %_type - cur_COUNTER += len_temp - len(entities) - settings.write(message, False) - settings.progress(cur_COUNTER, message) - if len(entities) > 0.1 / settings.obj_number: - show_progress = int(0.03 / settings.obj_number) - else: show_progress = 0 - cur_temp = 0 - - #print 'deb:drawer cur_COUNTER: ', cur_COUNTER #----------------------- - - for entity in entities: #----loop------------------------------------- - settings.write('\b.', False) - cur_COUNTER += 1 - if show_progress: - cur_temp += 1 - if cur_temp == show_progress: - settings.progress(cur_COUNTER, message) - cur_temp = 0 - #print 'deb:drawer show_progress=',show_progress #---------------- - - # get the layer group (just to make things a little cleaner) - if settings.var['group_bylayer_on'] and not block_def: - group = getGroup('l:%s' % layernamesmap[entity.layer]) - - if _type == 'insert': #---- INSERT and MINSERT=array -------------------- - if not settings.var['block_nn']: #----turn off support for noname BLOCKs - prefix = entity.name[:2] - if prefix in ('*X', '*U', '*D'): - #print 'deb:drawer entity.name:', entity.name #------------ - continue - if settings.var['blockFilter_on'] and not settings.accepted_block(entity.name): - continue - - #print 'deb:insert entity.loc:', entity.loc #---------------- - insertFlag = True - columns = entity.columns[0] - coldist = entity.columns[1] - rows = entity.rows[0] - rowdist = entity.rows[1] - deltaloc = [0,0,0] - #print 'deb:insert columns, rows:', columns, rows #----------- - for col in xrange(columns): - deltaloc[0] = col * coldist - for row in xrange(rows): - deltaloc[1] = row * rowdist - #print 'deb:insert col=%s, row=%s,deltaloc=%s' %(col, row, deltaloc) #------ - ob = entity.draw(settings, deltaloc) #-----draw BLOCK---------- - if block_def: - blockFlag = True - bl_loc = block_def[1] - ob.loc = [ob.loc[0]-bl_loc[0],ob.loc[1]-bl_loc[1],ob.loc[2]-bl_loc[2]] - else: blockFlag = False - setObjectProperties(ob, group, entity, settings, block_def) - if ob: - if settings.var['optimization'] <= settings.MIN: - #if settings.var['g_origin_on'] and not block_def: ob.loc = Mathutils.Vector(ob.loc) + settings.g_origin - if settings.var['g_scale_on']: globalScaleOne(ob, insertFlag, blockFlag, settings.var['g_scale']) - settings.redraw() - else: oblist.append((ob, insertFlag, blockFlag)) - - else: #---draw entities except BLOCKs/INSERTs--------------------- - insertFlag = False - alt_obname = activObjectName - ob = entity.draw(settings) - if ob: - if M_OBJ and ob.type=='Mesh': #'Curve', 'Text' - if block_def: - blockFlag = True - bl_loc = block_def[1] - ob.loc = [ob.loc[0]-bl_loc[0],ob.loc[1]-bl_loc[1],ob.loc[2]-bl_loc[2]] - car_nr() - - elif ob.name != alt_obname: - if block_def: - blockFlag = True - bl_loc = block_def[1] - ob.loc = [ob.loc[0]-bl_loc[0],ob.loc[1]-bl_loc[1],ob.loc[2]-bl_loc[2]] - else: blockFlag = False - setObjectProperties(ob, group, entity, settings, block_def) - if settings.var['optimization'] <= settings.MIN: - #if settings.var['g_origin_on'] and not block_def: ob.loc = Mathutils.Vector(ob.loc) + settings.g_origin - if settings.var['g_scale_on']: globalScaleOne(ob, insertFlag, blockFlag, settings.var['g_scale']) - settings.redraw() - else: oblist.append((ob, insertFlag, blockFlag)) - - #print 'deb:Finished drawing:', entities[0].type #------------------------ - message = "\nDrawing dxf\'%ss\' done!" % _type - settings.write(message, True) - - - -def globalScale(oblist, SCALE): #--------------------------------------------------------- - """Global_scale for list of all imported objects. - - oblist is a list of pairs (ob, insertFlag), where insertFlag=True/False - """ - #print 'deb:globalScale.oblist: ---------%\n', oblist #--------------------- - for l in oblist: - ob, insertFlag, blockFlag = l[0], l[1], l[2] - globalScaleOne(ob, insertFlag, blockFlag, SCALE) - - -def globalScaleOne(ob, insertFlag, blockFlag, SCALE): #--------------------------------------------------------- - """Global_scale imported object. - """ - #print 'deb:globalScaleOne ob: ', ob #--------------------- - if settings.var['g_origin_on'] and not blockFlag: - ob.loc = Mathutils.Vector(ob.loc) + settings.g_origin - - SCALE_MAT= Mathutils.Matrix([SCALE,0,0,0],[0,SCALE,0,0],[0,0,SCALE,0],[0,0,0,1]) - if insertFlag: # by BLOCKs/INSERTs only insert-point coords must be scaled------------ - ob.loc = Mathutils.Vector(ob.loc) * SCALE_MAT - else: # entire scaling for all other imported objects ------------ - if ob.type == 'Mesh': - me = ob.getData(name_only=False, mesh=True) - #me = Mesh.Get(ob.name) - # set centers of all objects in (0,0,0) - #me.transform(ob.matrixWorld*SCALE_MAT) - #ob.loc = Mathutils.Vector([0,0,0]) - # preseve centers of all objects - me.transform(SCALE_MAT) - ob.loc = Mathutils.Vector(ob.loc) * SCALE_MAT - else: #--todo-- also for curves: neutral scale factor after import - ob.setMatrix(ob.matrixWorld*SCALE_MAT) - - -def setObjectProperties(ob, group, entity, settings, block_def): #----------------------- - """Link object to scene. - """ - - if not ob: #remi--todo----------------------- - message = "\nObject \'%s\' not found!" %entity - settings.write(message) - return - - if group: - setGroup(group, ob) # if object belongs to group - - if block_def: # if object belongs to BLOCK_def - Move it to layer nr19 - setGroup(block_def[0], ob) - #print 'deb:setObjectProperties \'%s\' set to block_def_group!' %ob.name #--------- - ob.layers = [19] - else: - #ob.layers = [i+1 for i in xrange(20)] #remi--todo------------ - ob.layers = [settings.var['target_layer']] - - # Set material for any objects except empties - if ob.type != 'Empty' and settings.var['material_on']: - setMaterial_from(entity, ob, settings, block_def) - - # Set the visibility - #if settings.layer_isOff(entity.layer): - if layersmap and layersmap[entity.layer].color < 0: # color is negative if layer is off - #ob.layers = [20] #remi--todo------------- - ob.restrictDisplay = True - ob.restrictRender = True - - #print 'deb:\n---------linking Object %s!' %ob.name #---------- - - - -def getGroup(name): #----------------------------------------------------------------- - """Returns a Blender group-object. - """ - try: - group = Group.Get(name) - except: # What is the exception? - group = Group.New(name) - return group - - -def setGroup(group, ob): #------------------------------------------------------------ - """Assigns object to Blender group. - """ - try: - group.objects.link(ob) - except: - group.objects.append(ob) #remi?--------------- - - - -def setMaterial_from(entity, ob, settings, block_def): #------------------------------------------------ - """ Set Blender-material for the object controled by item. - - Set Blender-material for the object - - controlled by settings.var['material_from'] - """ - if settings.var['material_from'] == 1: # 1= material from color - if entity.color_index == BYLAYER or entity.color_index == 256: - mat = settings.colMaterials(entity.layer) - elif entity.color_index == BYBLOCK or entity.color_index == 0: - #--todo-- looking for block.color_index - #mat = settings.colMaterials(block.color_index) - #if block_def: mat = settings.colMaterials(block_def[2]) - mat = settings.colMaterials(3) - else: - mat = settings.colMaterials(entity.color_index) - - elif settings.var['material_from'] == 2: # 2= material from layer_name - mat = settings.layMaterials(layername=entity.layer) - - elif settings.var['material_from'] == 3: # 3= material from layer+color - mat = settings.layMaterials(layername=entity.layer, color=entity.color_index) - -# elif settings.var['material_from'] == 4: # 4= material from block_name - -# elif settings.var['material_from'] == 5: # 5= material from XDATA - -# elif settings.var['material_from'] == 6: # 6= material from INI-file - - else: # set neutral material - try: - mat = Material.Get('dxf-neutral') - except: - mat = Material.New('dxf-neutral') - mat.setRGBCol(color_map[3]) - try:mat.setMode('Shadeless', 'Wire') #work-around for 2.45rc1-bug - except: - mat.mode |= Material.Modes.SHADELESS # - mat.mode |= Material.Modes.WIRE - try: - #print 'deb:material mat:', mat #----------- - ob.setMaterials([mat]) #assigns Blender-material to object - except ValueError: - settings.write("material error - \'%s\'!" %mat) - ob.colbits = 0x01 # Set OB materials. - - - -def calcBulge(p1, p2, arc_res, triples=False): #------------------------------------------------- - """given startpoint, endpoint and bulge of arc, returns points/segments of its representation. - - Needs to take into account bulge sign. - negative = clockwise - positive = counter-clockwise - - to find center given two points, and arc angle - calculate radius - Cord = sqrt(start^2 + end^2) - S = (bulge*Cord)/2 - radius = ((Cord/2)^2+S^2)/2*S - angle of arc = 4*atan( bulge ) - angle from p1 to center is (180-angle)/2 - get vector pointing from p1 to p2 (p2 - p1) - normalize it and multiply by radius - rotate around p1 by angle to center, point to center. - start angle = angle between (center - p1) and worldX - end angle = angle between (center - p2) and worldX - - calculate the center, radius, start angle, and end angle - returns points/segments of its mesh representation - incl.startpoint, without endpoint - """ - - bulge = p1.bulge - p1 = Mathutils.Vector(p1.loc) - p2 = Mathutils.Vector(p2.loc) - cord = p2 - p1 # vector from p1 to p2 - clength = cord.length - s = (bulge * clength)/2.0 # sagitta (height) - radius = abs(((clength/2.0)**2.0 + s**2.0)/(2.0*s)) # magic formula - angle = (degrees(4.0*atan(bulge))) # theta (included angle) - radial = cord.normalize() * radius # a radius length vector aligned with cord - delta = (180.0 - abs(angle))/2.0 # the angle from cord to center - if bulge < 0: delta = -delta - rmat = Mathutils.RotationMatrix(-delta, 3, 'Z') - center = p1 + (rmat * radial) # rotate radial by delta degrees, then add to p1 to find center - #length = radians(abs(angle)) * radius - #print 'deb:calcBulge:\n angle, delta: ', angle, delta #---------------- - #print 'deb:center, radius: ', center, radius #---------------------- - startpoint = p1 - center - endpoint = p2 - center - #print 'deb:calcBulg: startpoint:', startpoint #--------- - #print 'deb:calcBulg: endpoint:', endpoint #--------- - - if not triples: #IF mesh-representation ----------- - if arc_res > 1024: arc_res = 1024 - elif arc_res < 4: arc_res = 4 - pieces = int(abs(angle)/(360.0/arc_res)) # set a fixed step of ARC_RESOLUTION - if pieces < 3: pieces = 3 - else: #IF curve-representation ------------------------------- - if arc_res > 32: arc_res = 32 - elif arc_res < 3: arc_res = 3 - pieces = int(abs(angle)/(360.0/arc_res)) # set a fixed step of ARC_RESOLUTION - if pieces < 2: pieces = 2 - - step = angle/pieces # set step so pieces * step = degrees in arc - stepmatrix = Mathutils.RotationMatrix(-step, 3, "Z") - - if not triples: #IF mesh-representation ----------- - points = [startpoint] - point = startpoint - for i in xrange(int(pieces)-1): #fast (but not so acurate as: vector * RotMatrix(-step*i,3,"Z") - point = stepmatrix * point - points.append(point) - points = [ point+center for point in points] - # vector to point convertion: - points = [list(point) for point in points] - return points, list(center) - - else: #IF curve-representation ------------------------------- - # correct Bezier curves representation for free segmented circles/arcs - step2 = radians(step * 0.5) - bulg = radius * (1 - cos(step2)) - deltaY = 4.0 * bulg / (3.0 * sin(step2) ) - #print 'deb:calcArcCurve: bulg, deltaY:\n', bulg, deltaY #--------- - #print 'deb:calcArcCurve: step:\n', step #--------- - - #org handler0 = Mathutils.Vector(0.0, -deltaY, 0.0) - #handler = startmatrix * handler0 - #endhandler = endmatrix * handler0 - rotMatr90 = Mathutils.Matrix([0, -1, 0], [1, 0, 0], [0, 0, 1]) - handler = rotMatr90 * startpoint - handler = - deltaY * handler.normalize() - endhandler = rotMatr90 * endpoint - endhandler = - deltaY * endhandler.normalize() - - points = [startpoint] - handlers1 = [startpoint + handler] - handlers2 = [startpoint - handler] - point = Mathutils.Vector(startpoint) - for i in xrange(int(pieces)-1): - point = stepmatrix * point - handler = stepmatrix * handler - handler1 = point + handler - handler2 = point - handler - points.append(point) - handlers1.append(handler1) - handlers2.append(handler2) - points.append(endpoint) - handlers1.append(endpoint + endhandler) - handlers2.append(endpoint - endhandler) - - points = [point + center for point in points] - handlers1 = [point + center for point in handlers1] - handlers2 = [point + center for point in handlers2] - - VectorTriples = [list(h1)+list(p)+list(h2) for h1,p,h2 in zip(handlers1, points, handlers2)] - #print 'deb:calcBulgCurve: handlers1:\n', handlers1 #--------- - #print 'deb:calcBulgCurve: points:\n', points #--------- - #print 'deb:calcBulgCurve: handlers2:\n', handlers2 #--------- - #print 'deb:calcBulgCurve: VectorTriples:\n', VectorTriples #--------- - return VectorTriples - - - - -def calcArc(center, radius, start, end, arc_res, triples): #----------------------------------------- - """calculate Points (or BezierTriples) for ARC/CIRCLEs representation. - - Given parameters of the ARC/CIRCLE, - returns points/segments (or BezierTriples) and centerPoint - """ - # center is currently set by object - # if start > end: start = start - 360 - if end > 360: end = end % 360.0 - - startmatrix = Mathutils.RotationMatrix(-start, 3, "Z") - startpoint = startmatrix * Mathutils.Vector(radius, 0, 0) - endmatrix = Mathutils.RotationMatrix(-end, 3, "Z") - endpoint = endmatrix * Mathutils.Vector(radius, 0, 0) - - if end < start: end +=360.0 - angle = end - start - #length = radians(angle) * radius - - if not triples: #IF mesh-representation ----------- - if arc_res > 1024: arc_res = 1024 - elif arc_res < 4: arc_res = 4 - pieces = int(abs(angle)/(360.0/arc_res)) # set a fixed step of ARC_RESOLUTION - if pieces < 3: pieces = 3 - step = angle/pieces # set step so pieces * step = degrees in arc - stepmatrix = Mathutils.RotationMatrix(-step, 3, "Z") - - points = [startpoint] - point = startpoint - for i in xrange(int(pieces)-1): - point = stepmatrix * point - points.append(point) - points.append(endpoint) - - if center: - centerVec = Mathutils.Vector(center) - #points = [point + centerVec for point in points()] - points = [point + centerVec for point in points] - # vector to point convertion: - points = [list(point) for point in points] - return points - - else: #IF curve-representation --------------- - if arc_res > 32: arc_res = 32 - elif arc_res < 3: arc_res = 3 - pieces = int(abs(angle)/(360.0/arc_res)) # set a fixed step of ARC_RESOLUTION - if pieces < 2: pieces = 2 - step = angle/pieces # set step so pieces * step = degrees in arc - stepmatrix = Mathutils.RotationMatrix(-step, 3, "Z") - - # correct Bezier curves representation for free segmented circles/arcs - step2 = radians(step * 0.5) - bulg = radius * (1 - cos(step2)) - deltaY = 4.0 * bulg / (3.0 * sin(step2) ) - #print 'deb:calcArcCurve: bulg, deltaY:\n', bulg, deltaY #--------- - #print 'deb:calcArcCurve: step:\n', step #--------- - handler0 = Mathutils.Vector(0.0, -deltaY, 0.0) - - points = [startpoint] - handler = startmatrix * handler0 - endhandler = endmatrix * handler0 - handlers1 = [startpoint + handler] - handlers2 = [startpoint - handler] - point = Mathutils.Vector(startpoint) - for i in xrange(int(pieces)-1): - point = stepmatrix * point - handler = stepmatrix * handler - handler1 = point + handler - handler2 = point - handler - points.append(point) - handlers1.append(handler1) - handlers2.append(handler2) - points.append(endpoint) - handlers1.append(endpoint + endhandler) - handlers2.append(endpoint - endhandler) - VectorTriples = [list(h1)+list(p)+list(h2) for h1,p,h2 in zip(handlers1, points, handlers2)] - #print 'deb:calcArcCurve: handlers1:\n', handlers1 #--------- - #print 'deb:calcArcCurve: points:\n', points #--------- - #print 'deb:calcArcCurve: handlers2:\n', handlers2 #--------- - #print 'deb:calcArcCurve: VectorTriples:\n', VectorTriples #--------- - return VectorTriples - - -def drawCurveCircle(circle): #--- no more used -------------------------------------------- - """Given a dxf circle object return a blender circle object using curves. - """ - c = Curve.New('circle') # create new curve data - center = circle.loc - radius = circle.radius - - p1 = (0, -radius, 0) - p2 = (radius, 0, 0) - p3 = (0, radius, 0) - p4 = (-radius, 0, 0) - - p1 = BezTriple.New(p1) - p2 = BezTriple.New(p2) - p3 = BezTriple.New(p3) - p4 = BezTriple.New(p4) - - curve = c.appendNurb(p1) - curve.append(p2) - curve.append(p3) - curve.append(p4) - for point in curve: - point.handleTypes = [AUTO, AUTO] - point.radius = 1.0 - curve.flagU = 1 # Set curve cyclic - c.update() - - ob = Object.New('Curve', 'circle') # make curve object - return ob - - -def drawCurveArc(self): #---- only for ELLIPSE ------------------------------------------------------------- - """Given a dxf ELLIPSE object return a blender_curve. - """ - center = self.loc - radius = self.radius - start = self.start_angle - end = self.end_angle - - if start > end: - start = start - 360.0 - startmatrix = Mathutils.RotationMatrix(start, 3, "Z") - startpoint = startmatrix * Mathutils.Vector((radius, 0, 0)) - endmatrix = Mathutils.RotationMatrix(end, 3, "Z") - endpoint = endmatrix * Mathutils.Vector((radius, 0, 0)) - # Note: handles must be tangent to arc and of correct length... - - a = Curve.New('arc') # create new curve data - - p1 = (0, -radius, 0) - p2 = (radius, 0, 0) - p3 = (0, radius, 0) - p4 = (-radius, 0, 0) - - p1 = BezTriple.New(p1) - p2 = BezTriple.New(p2) - p3 = BezTriple.New(p3) - p4 = BezTriple.New(p4) - - curve = a.appendNurb(p1) - curve.append(p2) - curve.append(p3) - curve.append(p4) - for point in curve: - point.handleTypes = [AUTO, AUTO] - point.radius = 1.0 - curve.flagU = 1 # Set curve cyclic - a.update() - - ob = Object.New('Curve', 'arc') # make curve object - return ob - - - - -# GUI STUFF -----#################################################----------------- -from Blender.BGL import glColor3f, glRecti, glClear, glRasterPos2d - -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_PRESETCURV = 10 -EVENT_PRESETS = 11 -EVENT_DXF_DIR = 12 -# = 13 -EVENT_LIST = 14 -EVENT_ORIGIN = 15 -EVENT_SCALE = 16 -EVENT_PRESET2D = 20 -EVENT_PRESET3D = 21 -EVENT_EXIT = 100 -GUI_EVENT = EVENT_NONE - -GUI_A = {} # GUI-buttons dictionary for parameter -GUI_B = {} # GUI-buttons dictionary for drawingTypes - -# settings default, initialize ------------------------ - -points_as_menu = "convert to: %t|empty %x1|mesh.vertex %x2|thin sphere %x3|thin box %x4|..curve.vertex %x5" -lines_as_menu = "convert to: %t|..edge %x1|mesh %x2|..thin cylinder %x3|thin box %x4|Bezier-curve %x5|..NURBS-curve %x6" -mlines_as_menu = "convert to: %t|..edge %x1|..mesh %x2|..thin cylinder %x3|..thin box %x|..curve %x5" -plines_as_menu = "convert to: %t|..edge %x1|mesh %x2|..thin cylinder %x3|..thin box %x4|Bezier-curve %x5|NURBS-curve %x6" -splines_as_menu = "convert to: %t|mesh %x2|..thin cylinder %x3|..thin box %x4|Bezier-curve %x5|NURBS-curve %x6" -plines3_as_menu = "convert to: %t|..edge %x1|mesh %x2|..thin cylinder %x3|..thin box %x4|Bezier-curve %x5|NURBS-curve %x6" -plmesh_as_menu = "convert to: %t|..edge %x1|mesh %x2|..NURBS-surface %x6" -solids_as_menu = "convert to: %t|..edge %x1|mesh %x2" -blocks_as_menu = "convert to: %t|dupliGroup %x1|..real.Group %x2|..exploded %x3" -texts_as_menu = "convert to: %t|text %x1|..mesh %x2|..curve %x5" -material_from_menu= "material from: %t|..LINESTYLE %x7|COLOR %x1|LAYER %x2|..LAYER+COLOR %x3|..BLOCK %x4|..XDATA %x5|..INI-File %x6" -g_scale_list = ''.join(( - 'scale factor: %t', - '|user def. %x12', - '|yard to m %x8', - '|feet to m %x7', - '|inch to m %x6', - '| 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 = { - 'curves_on' : 0, - 'optimization': 2, - 'one_mesh_on': 1, - 'vGroup_on' : 1, - 'dummy_on' : 0, - 'views_on' : 0, - 'cams_on' : 0, - 'lights_on' : 0, - 'xref_on' : 1, - 'block_nn': 0, - 'blockFilter_on': 0, - 'layerFilter_on': 0, - 'colorFilter_on': 0, - 'groupFilter_on': 0, - 'newScene_on' : 1, - 'target_layer' : TARGET_LAYER, - 'group_bylayer_on' : GROUP_BYLAYER, - 'g_originX' : G_ORIGIN_X, - 'g_originY' : G_ORIGIN_Y, - 'g_originZ' : G_ORIGIN_Z, - 'g_origin_on': 0, - 'g_scale' : float(G_SCALE), -# 'g_scale_as': int(log10(G_SCALE)), # 0, - 'g_scale_on': 0, - 'thick_on' : 1, - 'thick_min' : float(MIN_THICK), - 'thick_force': 0, - 'width_on' : 1, - 'width_min' : float(MIN_WIDTH), - 'width_force': 0, - 'dist_on' : 1, - 'dist_min' : float(MIN_DIST), - 'dist_force': 0, - 'material_on': 1, - 'material_from': 2, - 'fill_on' : 1, - 'meshSmooth_on': 1, - 'curve_res' : CURV_RESOLUTION, - 'curve_arc' : CURVARC_RESOLUTION, - 'arc_res' : ARC_RESOLUTION, - 'arc_rad' : ARC_RADIUS, - 'thin_res' : THIN_RESOLUTION, - 'pl_trim_max' : TRIM_LIMIT, - 'pl_trim_on': 1, - 'plmesh_flip': 0, - 'normals_out': 0, - 'paper_space_on': 0, - 'layFrozen_on': 0, - 'Z_force_on': 0, - 'Z_elev': float(ELEVATION), - 'points_as' : 2, - 'lines_as' : 2, - 'mlines_as' : 2, - 'plines_as' : 2, - 'splines_as' : 5, - 'plines3_as': 2, - 'plmesh_as' : 2, - 'solids_as' : 2, - 'blocks_as' : 1, - 'texts_as' : 1 - } - -drawTypes_org = { - 'point' : 1, - 'line' : 1, - 'arc' : 1, - 'circle': 1, - 'ellipse': 1, - 'mline' : 0, - 'polyline': 1, - 'spline': 1, - 'plmesh': 1, - 'pline3': 1, - 'lwpolyline': 1, - 'text' : 1, - 'mtext' : 0, - 'block' : 1, - 'insert': 1, - 'solid' : 1, - 'trace' : 1, - 'face' : 1, -# '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_Importer', cache) - if not rdict: rdict = {} - if item: - rdict[key] = item - Registry.SetKey('DXF_Importer', 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_Importer', 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 importer: INI-file: Alert!%t|no config-data present to save!') - else: - #if BPyMessages.Warning_SaveOver(iniFile): #<- remi find it too abstarct - if 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 importer: INI-file: Done!%t|config-data saved in ' + '\'%s\'' %iniFile) - except: - Draw.PupMenu('DXF importer: INI-file: Error!%t|failure by writing to ' + '\'%s\'|no config-data saved!' %iniFile) - - else: - Draw.PupMenu('DXF importer: INI-file: Alert!%t|no valid name/extension for INI-file selected!') - print "DXF importer: 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. - - Read material-assignements from config-file. - """ - #070724 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 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 importer: INI-file: Alert!%t|no valid header in INI-file: ' + '\'%s\'' %iniFile) - else: - Draw.PupMenu('DXF importer: INI-file: Alert!%t|no valid INI-file selected!') - print "DXF importer: 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_curv(activate): #----------------------------------------------- - """Sets settings/config/materials for curve representation. - - """ - global GUI_A - if activate: - GUI_A['curves_on'].val = 1 - GUI_A['points_as'].val = 5 - GUI_A['lines_as'].val = 5 - GUI_A['mlines_as'].val = 5 - GUI_A['plines_as'].val = 5 - GUI_A['splines_as'].val = 5 - GUI_A['plines3_as'].val = 5 - else: - GUI_A['curves_on'].val = 0 - GUI_A['points_as'].val = 2 - GUI_A['lines_as'].val = 2 - GUI_A['mlines_as'].val = 2 - GUI_A['plines_as'].val = 2 - GUI_A['splines_as'].val = 6 - GUI_A['plines3_as'].val = 2 - - -def resetDefaultConfig_2D(): #----------------------------------------------- - """Sets settings/config/materials to defaults 2D. - - """ - presetConfig_curv(1) - keywords2d = { - 'views_on' : 0, - 'cams_on' : 0, - 'lights_on' : 0, - 'vGroup_on' : 1, - 'thick_on' : 0, - 'thick_force': 0, - 'width_on' : 1, - 'width_force': 0, - 'dist_on' : 1, - 'dist_force': 0, - 'fill_on' : 0, - 'pl_trim_on': 1, - 'Z_force_on': 0, - 'meshSmooth_on': 0, - 'solids_as' : 2, - 'blocks_as' : 1, - 'texts_as' : 1 - } - - drawTypes2d = { - 'point' : 1, - 'line' : 1, - 'arc' : 1, - 'circle': 1, - 'ellipse': 1, - 'mline' : 0, - 'polyline': 1, - 'spline': 1, - 'plmesh': 0, - 'pline3': 1, - 'lwpolyline': 1, - 'text' : 1, - 'mtext' : 0, - 'block' : 1, - 'insert': 1, - 'solid' : 1, - 'trace' : 1, - 'face' : 0, -# 'view' : 0, - } - - updateConfig(keywords2d, drawTypes2d) - -def resetDefaultConfig_3D(): #----------------------------------------------- - """Sets settings/config/materials to defaults 3D. - - """ - presetConfig_curv(0) - keywords3d = { -# 'views_on' : 1, -# 'cams_on' : 1, -# 'lights_on' : 1, - 'vGroup_on' : 1, - 'thick_on' : 1, - 'thick_force': 0, - 'width_on' : 1, - 'width_force': 0, - 'dist_on' : 1, - 'dist_force': 0, - 'fill_on' : 1, - 'pl_trim_on': 1, - 'Z_force_on': 0, - 'meshSmooth_on': 1, - 'solids_as' : 2, - 'blocks_as' : 1, - 'texts_as' : 1 - } - - drawTypes3d = { - 'point' : 1, - 'line' : 1, - 'arc' : 1, - 'circle': 1, - 'ellipse': 1, - 'mline' : 0, - 'polyline': 1, - 'spline': 1, - 'plmesh': 1, - 'pline3': 1, - 'lwpolyline': 1, - 'text' : 0, - 'mtext' : 0, - 'block' : 1, - 'insert': 1, - 'solid' : 1, - 'trace' : 1, - 'face' : 1, -# 'view' : 0, - } - - 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 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 - - # This is for easy layout changes - but_0c = 70 #button 1.column width - but_1c = 70 #button 1.column width - but_2c = 70 #button 2.column - but_3c = 70 #button 3.column - menu_margin = 10 - butt_margin = 10 - menu_w = (3 * butt_margin) + but_0c + but_1c + but_2c + but_3c #menu width - - simple_menu_h = 100 - extend_menu_h = 350 - y = simple_menu_h # y is menu upper.y - if config_UI.val: y += extend_menu_h - x = 20 #menu left.x - 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) - - y += 30 - colorbox(x, y+20, x+menu_w+menu_margin*2, menu_margin) - Draw.Label("DXF/DWG-Importer v" + __version__, but0c, y, menu_w, 20) - - if config_UI.val: - b0, b0_ = but0c, but_0c + butt_margin - b1, b1_ = but1c, but_1c - y_top = y - - y -= 10 - y -= 20 - Draw.BeginAlign() - GUI_B['point'] = Draw.Toggle('POINT', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['point'].val, "support dxf-POINT on/off") - if GUI_B['point'].val: - GUI_A['points_as'] = Draw.Menu(points_as_menu, EVENT_NONE, b1, y, b1_, 20, GUI_A['points_as'].val, "select target Blender-object") -# Draw.Label('-->', but2c, y, but_2c, 20) - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['line'] = Draw.Toggle('LINE...etc', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['line'].val, "support dxf-LINE,ARC,CIRCLE,ELLIPSE on/off") - if GUI_B['line'].val: - GUI_A['lines_as'] = Draw.Menu(lines_as_menu, EVENT_NONE, but1c, y, but_1c, 20, GUI_A['lines_as'].val, "select target Blender-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['mline'] = Draw.Toggle('..MLINE', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['mline'].val, "(*todo)support dxf-MLINE on/off") - if GUI_B['mline'].val: - GUI_A['mlines_as'] = Draw.Menu(mlines_as_menu, EVENT_NONE, but1c, y, but_1c, 20, GUI_A['mlines_as'].val, "select target Blender-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['spline'] = Draw.Toggle('SPLINE', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['spline'].val, "support dxf-SPLINE on/off") - if GUI_B['spline'].val: - GUI_A['splines_as'] = Draw.Menu(splines_as_menu, EVENT_NONE, but1c, y, but_1c, 20, GUI_A['splines_as'].val, "select target Blender-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['polyline'] = Draw.Toggle('2D/LWPLINE', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['polyline'].val, "support dxf-2D-POLYLINE on/off") - if GUI_B['polyline'].val: - GUI_A['plines_as'] = Draw.Menu(plines_as_menu, EVENT_NONE, but1c, y, but_1c, 20, GUI_A['plines_as'].val, "select target Blender-object") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_B['pline3'] = Draw.Toggle('3D-PLINE', EVENT_REDRAW, b0, y, b0_, 20, GUI_B['pline3'].val, "support dxf-3D-POLYLINE on/off") - if GUI_B['pline3'].val: - GUI_A['plines3_as'] = Draw.Menu(plines3_as_menu, EVENT_NONE, but1c, y, but_1c, 20, GUI_A['plines3_as'].val, "select target Blender-object") - Draw.EndAlign() - - y_down = y - # ----------------------------------------------- - - y = y_top - b0, b0_ = but2c, but_2c + butt_margin - b1, b1_ = but3c, but_3c - - y -= 10 - y -= 20 - Draw.BeginAlign() - GUI_B['plmesh'] = Draw.Toggle('PL-MESH/FACE', EVENT_NONE, b0, y, b0_+b1_-40, 20, GUI_B['plmesh'].val, "support dxf-POLYMESH/POLYFACE on/off") -# GUI_A['plmesh_as'] = Draw.Menu(plmesh_as_menu, EVENT_NONE, but1c, y, but_1c, 20, GUI_A['plmesh_as'].val, "select target Blender-object") - GUI_A['plmesh_flip'] = Draw.Toggle('N', EVENT_NONE, b1+b1_-40, y, 20, 20, GUI_A['plmesh_flip'].val, "flip DXF normals on/off") - GUI_A['normals_out'] = Draw.Toggle('N', EVENT_NONE, b1+b1_-20, y, 20, 20, GUI_A['normals_out'].val, "force Blender normals to outside on/off") - Draw.EndAlign() - - y -= 20 - GUI_B['solid'] = Draw.Toggle('SOLID', EVENT_NONE, b0, y, b0_, 20, GUI_B['solid'].val, "support dxf-SOLID and TRACE on/off") - GUI_B['face'] = Draw.Toggle('3DFACE', EVENT_NONE, b1, y, b1_, 20, GUI_B['face'].val, "support dxf-3DFACE on/off") -# GUI_A['solids_as'] = Draw.Menu(solids_as_menu, EVENT_NONE, but3c, y, but_3c, 20, GUI_A['solids_as'].val, "select target Blender-object") - #print 'deb:support solid, trace', GUI_B['trace'].val, GUI_B['solid'].val # ------------ - - - y -= 20 - GUI_B['text'] = Draw.Toggle('TEXT', EVENT_NONE, b0, y, b0_, 20, GUI_B['text'].val, "support dxf-TEXT on/off") - GUI_B['mtext'] = Draw.Toggle('..MTEXT', EVENT_NONE, b1, y, b1_, 20, GUI_B['mtext'].val, "(*todo)support dxf-MTEXT on/off") -# GUI_A['texts_as'] = Draw.Menu(texts_as_menu, EVENT_NONE, but3c, y, but_3c, 20, GUI_A['texts_as'].val, "select target Blender-object") - - y -= 20 - Draw.BeginAlign() - GUI_B['block'] = Draw.Toggle('BLOCK', EVENT_REDRAW, b0, y, b0_-30, 20, GUI_B['block'].val, "support dxf-BLOCK and ARRAY on/off") - GUI_B['insert'].val = GUI_B['block'].val - if GUI_B['block'].val: - GUI_A['block_nn'] = Draw.Toggle('n', EVENT_NONE, b1-30, y, 15, 20, GUI_A['block_nn'].val, "support hatch/noname BLOCKs *X... on/off") - GUI_A['xref_on'] = Draw.Toggle('Xref', EVENT_NONE, b1-15, y, 35, 20, GUI_A['xref_on'].val, "support for XREF-BLOCKs (place holders) on/off") - GUI_A['blocks_as'] = Draw.Menu(blocks_as_menu, EVENT_NONE, b1+20, y, b1_-20, 20, GUI_A['blocks_as'].val, "select target representation for imported BLOCKs") - Draw.EndAlign() - - - y -= 20 - y -= 20 - - Draw.BeginAlign() - GUI_A['views_on'] = Draw.Toggle('views', EVENT_NONE, b0, y, b0_-25, 20, GUI_A['views_on'].val, "imports VIEWs and VIEWPORTs as cameras on/off") - GUI_A['cams_on'] = Draw.Toggle('..cams', EVENT_NONE, b1-25, y, b1_-25, 20, GUI_A['cams_on'].val, "(*todo) support ASHADE cameras on/off") - GUI_A['lights_on'] = Draw.Toggle('..lights', EVENT_NONE, b1+25, y, b1_-25, 20, GUI_A['lights_on'].val, "(*todo) support AVE_RENDER lights on/off") - 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['paper_space_on'] = Draw.Toggle('paper', EVENT_NONE, b0+but_*0, y, but_, 20, GUI_A['paper_space_on'].val, "import only from Paper-Space on/off") - GUI_A['layFrozen_on'] = Draw.Toggle ('frozen', EVENT_NONE, b0+but_*1, y, but_, 20, GUI_A['layFrozen_on'].val, "import also from frozen LAYERs on/off") - GUI_A['layerFilter_on'] = Draw.Toggle('..layer', EVENT_NONE, b0+but_*2, y, but_, 20, GUI_A['layerFilter_on'].val, "(*todo) LAYER 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['blockFilter_on'] = Draw.Toggle('..block', EVENT_NONE, b0+but_*5, y, but_, 20, GUI_A['blockFilter_on'].val, "(*todo) BLOCK filtering on/off") - #GUI_A['dummy_on'] = Draw.Toggle('-', EVENT_NONE, but3c, y, but_3c, 20, GUI_A['dummy_on'].val, "dummy 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('glob.reLoc', EVENT_REDRAW, b0, y, b0_, 20, GUI_A['g_origin_on'].val, "global relocate all DXF 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) - #GUI_A['g_origin'] = Draw.String('', EVENT_ORIGIN, b1, y, b1_, 20, GUI_A['g_origin'].val, "global translation-vector (x,y,z) in DXF units") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_A['g_scale_on'] = Draw.Toggle('glob.Scale', EVENT_REDRAW, b0, y, b0_, 20, GUI_A['g_scale_on'].val, "global scale all DXF 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_down = y - # -----end material,translate,scale------------------------------------------ - - b0, b0_ = but0c, but_0c + butt_margin - b1, b1_ = but1c, but_1c - - y_top = y_down - y = y_top - y -= 10 - y -= 20 - Draw.BeginAlign() - GUI_A['meshSmooth_on'] = Draw.Toggle('smooth', EVENT_NONE, b0, y, b0_-20, 20, GUI_A['meshSmooth_on'].val, "mesh smooth for circles/arc-segments on/off") - GUI_A['pl_trim_on'] = Draw.Toggle('trim', EVENT_NONE, b1-20, y, 32, 20, GUI_A['pl_trim_on'].val, "clean intersection of POLYLINE-wide-segments on/off") - GUI_A['pl_trim_max'] = Draw.Number('', EVENT_NONE, b1+12, y, b1_-12, 20, GUI_A['pl_trim_max'].val, 0, 5, "threshold intersection of POLYLINE-wide-segments: 0.0-5.0") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() -# GUI_A['thin_res'] = Draw.Number('thin:', EVENT_NONE, but0c, y, but_0c, 20, GUI_A['thin_res'].val, 4, 64, "thin cylinder resolution - number of segments (4-64)") - GUI_A['arc_rad'] = Draw.Number('bR:', EVENT_NONE, b0, y, b0_, 20, GUI_A['arc_rad'].val, 0.01, 100, "basis radius for arc/circle resolution (0.01-100)") - GUI_A['arc_res'] = Draw.Number('', EVENT_NONE, b1, y, b1_/2, 20, GUI_A['arc_res'].val, 3, 500, "arc/circle resolution - number of segments (3-500)") - GUI_A['fill_on'] = Draw.Toggle('caps', EVENT_NONE, b1+b1_/2, y, b1_/2, 20, GUI_A['fill_on'].val, "draws top and bottom caps of CYLINDERs/closed curves on/off") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_A['curve_arc'] = Draw.Number('', EVENT_NONE, b0, y, b0_/2, 20, GUI_A['curve_arc'].val, 3, 32, "Bezier circle: amount of segments: 3-32") - GUI_A['curve_res'] = Draw.Number('', EVENT_NONE, b0+b0_/2, y, b0_/2, 20, GUI_A['curve_res'].val, 1, 128, "Set the Curve's U-resolution value: 1-128") - GUI_A['curves_on'] = Draw.Toggle('to Curves', EVENT_PRESETCURV, b1, y, b1_, 20, GUI_A['curves_on'].val, "set Curve as target object type on/off") - Draw.EndAlign() - - y -= 20 - GUI_A['group_bylayer_on'] = Draw.Toggle('Layer', EVENT_NONE, b0, y, 30, 20, GUI_A['group_bylayer_on'].val, "DXF-entities group by layer on/off") - GUI_A['vGroup_on'] = Draw.Toggle('vGroups', EVENT_NONE, b0+30, y, b1_-10, 20, GUI_A['vGroup_on'].val, "sort faces into VertexGroups on/off") - GUI_A['one_mesh_on'] = Draw.Toggle('oneMesh', EVENT_NONE, b1+10, y, b1_-10, 20, GUI_A['one_mesh_on'].val, "draw DXF-entities into one mesh-object. Recommended for big DXF-files. on/off") - - 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_from'] = Draw.Menu(material_from_menu, EVENT_NONE, b1-20, y, b1_+20, 20, GUI_A['material_from'].val, "material assignment from?") - Draw.EndAlign() - - y_down = y - # ----------------------------------------------- - - b0, b0_ = but2c, but_2c + butt_margin - b1, b1_ = but3c, but_3c - - y = y_top - y -= 10 - y -= 20 - Draw.BeginAlign() - GUI_A['Z_force_on'] = Draw.Toggle('.elevation', EVENT_REDRAW, b0, y, b0_, 20, GUI_A['Z_force_on'].val, ".set objects Z-coordinates to elevation 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 default elevation(Z-coordinate)") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_A['dist_on'] = Draw.Toggle('dist.:', EVENT_NONE, b0, y, b0_-20, 20, GUI_A['dist_on'].val, "support distance on/off") - GUI_A['dist_force'] = Draw.Toggle('F', EVENT_NONE, b0+b0_-20, y, 20, 20, GUI_A['dist_force'].val, "force minimal distance on/off") - GUI_A['dist_min'] = Draw.Number('', EVENT_NONE, b1, y, b1_, 20, GUI_A['dist_min'].val, 0, 10, "minimal length/distance (double.vertex removing)") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_A['thick_on'] = Draw.Toggle('thick:', EVENT_NONE, b0, y, b0_-20, 20, GUI_A['thick_on'].val, "support thickness on/off") - GUI_A['thick_force'] = Draw.Toggle('F', EVENT_REDRAW, b0+b0_-20, y, 20, 20, GUI_A['thick_force'].val, "force for thickness at least limiter value on/off") - if GUI_A['thick_force'].val: - GUI_A['thick_min'] = Draw.Number('', EVENT_NONE, b1, y, b1_, 20, GUI_A['thick_min'].val, 0, 10, "minimal value for thickness") - Draw.EndAlign() - - y -= 20 - Draw.BeginAlign() - GUI_A['width_on'] = Draw.Toggle('width:', EVENT_NONE, b0, y, b0_-20, 20, GUI_A['width_on'].val, "support width on/off") - GUI_A['width_force'] = Draw.Toggle('F', EVENT_REDRAW, b0+b0_-20, y, 20, 20, GUI_A['width_force'].val, "force for width at least limiter value on/off") - if GUI_A['width_force'].val: - GUI_A['width_min'] = Draw.Number('', EVENT_NONE, b1, y, b1_, 20, GUI_A['width_min'].val, 0, 10, "minimal value for width") - Draw.EndAlign() - - y -= 30 - but, but_ = but2c, 25 - Draw.BeginAlign() - Draw.EndAlign() - - if y < y_down: y_down = y - # -----end options -------------------------------------- - - - #-------------------------------------- - y_top = y_down - y = y_top - #GUI_A['dummy_on'] = Draw.Toggle(' - ', EVENT_NONE, but0c, y, but_0c, 20, GUI_A['dummy_on'].val, "reserved") - y -= 30 - Draw.BeginAlign() - Draw.PushButton('INI file >', EVENT_CHOOSE_INI, but0c, y, but_0c, 20, 'Select INI-file from project directory') - 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 ini-file: %s' % iniFileName.val) - Draw.PushButton('S', EVENT_SAVE_INI, but+40, y, 20, 20, 'Saves configuration to ini-file: %s' % iniFileName.val) - Draw.EndAlign() - - - b0, b0_ = but2c, but_2c + butt_margin - b1, b1_ = but3c, but_3c - - y = simple_menu_h - bm = butt_margin/2 - - #y -= 10 - Draw.BeginAlign() - Draw.PushButton('DXFfile >', EVENT_CHOOSE_DXF, but0c, y, but_0c, 20, 'Select DXF/DWG-file for import') - dxfFileName = Draw.String(' :', EVENT_NONE, but1c, y, but_1c+but_2c+but_3c-20, 20, dxfFileName.val, FILENAME_MAX, "type the name of DXF/DWG-file or type *.dxf/*.dwg for multiple files") - Draw.PushButton('*.*', EVENT_DXF_DIR, but3c+but_3c-20, y, 20, 20, 'set filter for import all files from this directory') - 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 configuration for 2D import') - Draw.PushButton('3D', EVENT_PRESET3D, but+(but_*2), y, but_, 20, 'set configuration for 3D import') - Draw.EndAlign() - - Draw.BeginAlign() - GUI_A['newScene_on'] = Draw.Toggle('newScene', EVENT_NONE, but2c, y, but_2c, 20, GUI_A['newScene_on'].val, "create new Scene for each imported dxf file on/off") - GUI_A['target_layer'] = Draw.Number('layer', EVENT_NONE, but3c, y, but_3c, 20, GUI_A['target_layer'].val, 1, 18, "target Blender-layer (<19> reserved for block_definitions)") - Draw.EndAlign() - - y -= 40 - Draw.PushButton('EXIT', EVENT_EXIT, but0c, y, but_0c+bm, 20, '' ) - Draw.PushButton('HELP', EVENT_HELP, but1c, y, but_1c+bm, 20, 'calls DXF-Importer Manual Page on Wiki.Blender.org') - Draw.BeginAlign() - GUI_A['optimization'] = Draw.Number('', EVENT_NONE, but2c, y+20, 40, 20, GUI_A['optimization'].val, 0, 3, "Optimization Level: 0=Debug/directDrawing, 1=Verbose, 2=ProgressBar, 3=SilentMode") - Draw.EndAlign() - Draw.BeginAlign() - Draw.PushButton('TEST', EVENT_LIST, but2c, y, 40, 20, 'DXF-Analyze-Tool: reads data from selected dxf file and writes report in project_directory/dxf_blendname.INF') - Draw.PushButton('START IMPORT', EVENT_START, but2c+40, y, but_2c-40+but_3c+butt_margin, 40, 'Start the import 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(' ', but0c+menu_w, y, menu_margin, 20) - Draw.EndAlign() - -#-- END GUI Stuf----------------------------------------------------- - -def colorbox(x,y,xright,bottom): - glColor3f(0.75, 0.75, 0.75) - glRecti(x + 1, y + 1, xright - 1, bottom - 1) - -def dxf_callback(input_filename): - global dxfFileName - if input_filename.lower()[-3:] in ('dwg','dxf'): - dxfFileName.val=input_filename -# dirname == 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 event(evt, val): - if evt in (Draw.QKEY, Draw.ESCKEY) and not val: - Draw.Exit() - -def bevent(evt): -# global EVENT_NONE,EVENT_LOAD_DXF,EVENT_LOAD_INI,EVENT_SAVE_INI,EVENT_EXIT - global config_UI, user_preset - global GUI_A, UI_MODE - - ######### Manages GUI events - if (evt==EVENT_EXIT): - Draw.Exit() - print 'DXF/DWG-Importer *** exit ***' #--------------------- - 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_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_PRESET3D): - resetDefaultConfig_3D() - Draw.Redraw() - elif (evt==EVENT_PRESETCURV): - presetConfig_curv(GUI_A['curves_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_LIST): - dxfFile = dxfFileName.val - update_RegistryKey('dxfFileName', dxfFileName.val) - if dxfFile.lower().endswith('.dxf') and sys.exists(dxfFile): - analyzeDXF(dxfFile) - else: - Draw.PupMenu('DXF importer: Alert!%t|no valid DXF-file selected!') - print "DXF importer: error, no valid DXF-file selected! try again" - Draw.Redraw() - elif (evt==EVENT_HELP): - try: - import webbrowser - webbrowser.open('http://wiki.blender.org/index.php?title=Scripts/Manual/Import/DXF-3D') - except: - Draw.PupMenu('DXF importer: HELP Alert!%t|no connection to manual-page on Blender-Wiki! try:|\ -http://wiki.blender.org/index.php?title=Scripts/Manual/Import/DXF-3D') - 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 - dxfFileExt = '*'+dxfFile.lower()[-4:] #can be .dxf or .dwg - dxfPathName = '' - if '/' in dxfFile: - dxfPathName = '/'.join(dxfFile.split('/')[:-1]) + '/' - elif '\\' in dxfFile: - dxfPathName = '\\'.join(dxfFile.split('\\')[:-1]) + '\\' - dxfFileName.val = dxfPathName + dxfFileExt -# dirname == sys.dirname(Blender.Get('filename')) -# update_RegistryKey('DirName', dirname) -# update_RegistryKey('dxfFileName', dxfFileName.val) - GUI_A['newScene_on'].val = 1 - Draw.Redraw() - elif (evt==EVENT_CHOOSE_DXF): - filename = '' # '*.dxf' - if dxfFileName.val: filename = dxfFileName.val - Window.FileSelector(dxf_callback, "DXF/DWG-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) - if dxfFile.lower().endswith('*.dxf'): - if Draw.PupMenu('DXF importer will import all DXF-files from:|%s|OK?' % dxfFile) != -1: - UI_MODE = False - multi_import(dxfFile) - UI_MODE = True - Draw.Redraw() - - elif dxfFile.lower().endswith('*.dwg'): - if not extCONV_OK: Draw.PupMenu(extCONV_TEXT) - elif Draw.PupMenu('DWG importer will import all DWG-files from:|%s|OK?' % dxfFile) != -1: - #elif Draw.PupMenu('DWG importer will import all DWG-files from:|%s|Caution! overwrites existing DXF-files!| OK?' % dxfFile) != -1: - UI_MODE = False - multi_import(dxfFile) - UI_MODE = True - Draw.Redraw() - - elif sys.exists(dxfFile) and dxfFile.lower()[-4:] in ('.dxf','.dwg'): - if dxfFile.lower().endswith('.dwg') and (not extCONV_OK): - Draw.PupMenu(extCONV_TEXT) - else: - #print '\nStandard Mode: active' - if GUI_A['newScene_on'].val: - _dxf_file = dxfFile.split('/')[-1].split('\\')[-1] - _dxf_file = _dxf_file[:-4] # cut last char:'.dxf' - _dxf_file = _dxf_file[:MAX_NAMELENGTH] #? [-MAX_NAMELENGTH:]) - global SCENE - SCENE = Blender.Scene.New(_dxf_file) - SCENE.makeCurrent() - Blender.Redraw() - #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) - #SCENE.objects.selected = SCENE.objects - #Window.RedrawAll() - #Blender.Redraw() - #Draw.Redraw() - else: - Draw.PupMenu('DXF importer: nothing imported!%t|no valid DXF-file selected!') - print "DXF importer: nothing imported, no valid DXF-file selected! try again" - Draw.Redraw() - - - - -def multi_import(DIR): - """Imports all DXF-files from directory DIR. - - """ - global SCENE - batchTIME = sys.time() - #if #DIR == "": DIR = os.path.curdir - if DIR == "": - DIR = sys.dirname(Blender.Get('filename')) - EXT = '.dxf' - else: - EXT = DIR[-4:] # get last 4 characters '.dxf' - DIR = DIR[:-5] # cut last 5 characters '*.dxf' - print 'importing multiple %s files from %s' %(EXT,DIR) - files = \ - [sys.join(DIR, f) for f in os.listdir(DIR) if f.lower().endswith(EXT)] - if not files: - print '...None %s-files found. Abort!' %EXT - return - - i = 0 - for dxfFile in files: - i += 1 - print '\n%s-file' %EXT, i, 'of', len(files) #,'\nImporting', dxfFile - if GUI_A['newScene_on'].val: - _dxf_file = dxfFile.split('/')[-1].split('\\')[-1] - _dxf_file = _dxf_file[:-4] # cut last char:'.dxf' - _dxf_file = _dxf_file[:MAX_NAMELENGTH] #? [-MAX_NAMELENGTH:]) - 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' % (sys.time() - batchTIME) - print '\a\r', # beep when done - Draw.PupMenu('DXF importer: Done!|finished in %.4f sec.' % (sys.time() - batchTIME)) - - -if __name__ == "__main__": - #Draw.PupMenu('DXF importer: Abort%t|This script version works for Blender up 2.49 only!') - UI_MODE = True - # 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 = sys.dirname(Blender.Get('filename')) - #print 'deb:start dirname:', dirname #---------------- - dxfFileName.val = sys.join(dirname, '') - inifilename = check_RegistryKey('iniFileName') - if inifilename: iniFileName.val = inifilename - - Draw.Register(draw_UI, event, bevent) - - -""" -if 1: - # DEBUG ONLY - UI_MODE = False - TIME= sys.time() - #DIR = '/dxf_r12_testfiles/' - DIR = '/metavr/' - import os - print 'Searching for files' - os.system('find %s -iname "*.dxf" > /tmp/tempdxf_list' % DIR) - # os.system('find /storage/ -iname "*.dxf" > /tmp/tempdxf_list') - print '...Done' - file= open('/tmp/tempdxf_list', 'r') - lines= file.readlines() - file.close() - # sort by filesize for faster testing - lines_size = [(os.path.getsize(f[:-1]), f[:-1]) for f in lines] - lines_size.sort() - lines = [f[1] for f in lines_size] - - for i, _dxf in enumerate(lines): - if i >= 70: - #if 1: - print 'Importing', _dxf, '\nNUMBER', i, 'of', len(lines) - if True: - _dxf_file= _dxf.split('/')[-1].split('\\')[-1] - _dxf_file = _dxf_file[:-4] # cut last char:'.dxf' - _dxf_file = _dxf_file[:MAX_NAMELENGTH] #? [-MAX_NAMELENGTH:]) - sce = bpy.data.scenes.new(_dxf_file) - bpy.data.scenes.active = sce - dxfFileName.val = _dxf - main(_dxf) - - print 'TOTAL TIME: %.6f' % (sys.time() - TIME) -"""
\ No newline at end of file |