forked from bartvdbraak/blender
739 lines
24 KiB
Python
739 lines
24 KiB
Python
#dxfLibrary.py : provides functions for generating DXF files
|
|
# --------------------------------------------------------------------------
|
|
__version__ = "v1.29beta - 2008.12.28"
|
|
__author__ = "Stani Michiels(Stani), Remigiusz Fiedler(migius)"
|
|
__license__ = "GPL"
|
|
__url__ = "http://wiki.blender.org/index.php/Scripts/Manual/Export/autodesk_dxf"
|
|
__bpydoc__ ="""The library to export geometry data to DXF format r12 version.
|
|
|
|
Copyright %s
|
|
Version %s
|
|
License %s
|
|
Homepage %s
|
|
|
|
See the homepage for documentation.
|
|
Dedicated thread on BlenderArtists: http://blenderartists.org/forum/showthread.php?t=136439
|
|
|
|
IDEAs:
|
|
-
|
|
|
|
TODO:
|
|
- add support for SPLINEs, (bad idea, cause DXF r14 object :(
|
|
|
|
History
|
|
v1.29 - 2008.12.28 by Yorik
|
|
- modif POLYLINE to support bulge segments
|
|
v1.28 - 2008.12.13 by Steeve/BlenderArtists
|
|
- bugfix for EXTMIN/EXTMAX to suit Cycas-CAD
|
|
v1.27 - 2008.10.07 by migius
|
|
- beautifying output code: keys whitespace prefix
|
|
- refactoring DXF-strings format: NewLine moved to the end of
|
|
v1.26 - 2008.10.05 by migius
|
|
- modif POLYLINE to support POLYFACE
|
|
v1.25 - 2008.09.28 by migius
|
|
- modif FACE class for r12
|
|
v1.24 - 2008.09.27 by migius
|
|
- modif POLYLINE class for r12
|
|
- changing output format from r9 to r12(AC1009)
|
|
v1.1 (20/6/2005) by www.stani.be/python/sdxf
|
|
- Python library to generate dxf drawings
|
|
______________________________________________________________
|
|
""" % (__author__,__version__,__license__,__url__)
|
|
|
|
# --------------------------------------------------------------------------
|
|
# DXF Library: copyright (C) 2005 by Stani Michiels (AKA Stani)
|
|
# 2008 modif by Remigiusz Fiedler (AKA migius)
|
|
# --------------------------------------------------------------------------
|
|
# ***** BEGIN GPL LICENSE BLOCK *****
|
|
#
|
|
# This program is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License
|
|
# as published by the Free Software Foundation; either version 2
|
|
# of the License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software Foundation,
|
|
# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
#
|
|
# ***** END GPL LICENCE BLOCK *****
|
|
|
|
|
|
#import Blender
|
|
#from Blender import Mathutils, Window, Scene, sys, Draw
|
|
#import BPyMessages
|
|
|
|
try:
|
|
import copy
|
|
#from struct import pack
|
|
except:
|
|
copy = None
|
|
|
|
####1) Private (only for developpers)
|
|
_HEADER_POINTS=['insbase','extmin','extmax']
|
|
|
|
#---helper functions-----------------------------------
|
|
def _point(x,index=0):
|
|
"""Convert tuple to a dxf point"""
|
|
#print 'deb: _point=', x #-------------
|
|
return '\n'.join([' %s\n%s'%((i+1)*10+index,x[i]) for i in range(len(x))])
|
|
|
|
def _points(plist):
|
|
"""Convert a list of tuples to dxf points"""
|
|
out = '\n'.join([_point(plist[i],i)for i in range(len(plist))])
|
|
#print 'deb: points=\n', out #-------------------
|
|
return out
|
|
|
|
#---base classes----------------------------------------
|
|
class _Call:
|
|
"""Makes a callable class."""
|
|
def copy(self):
|
|
"""Returns a copy."""
|
|
return copy.deepcopy(self)
|
|
|
|
def __call__(self,**attrs):
|
|
"""Returns a copy with modified attributes."""
|
|
copied=self.copy()
|
|
for attr in attrs:setattr(copied,attr,attrs[attr])
|
|
return copied
|
|
|
|
#-------------------------------------------------------
|
|
class _Entity(_Call):
|
|
"""Base class for _common group codes for entities."""
|
|
def __init__(self,color=None,extrusion=None,layer='0',
|
|
lineType=None,lineTypeScale=None,lineWeight=None,
|
|
thickness=None,parent=None):
|
|
"""None values will be omitted."""
|
|
self.color = color
|
|
self.extrusion = extrusion
|
|
self.layer = layer
|
|
self.lineType = lineType
|
|
self.lineTypeScale = lineTypeScale
|
|
self.lineWeight = lineWeight
|
|
self.thickness = thickness
|
|
self.parent = parent
|
|
|
|
def _common(self):
|
|
"""Return common group codes as a string."""
|
|
if self.parent:parent=self.parent
|
|
else:parent=self
|
|
result =''
|
|
if parent.layer!=None: result+=' 8\n%s\n'%parent.layer
|
|
if parent.color!=None: result+=' 62\n%s\n'%parent.color
|
|
if parent.extrusion!=None: result+='%s\n'%_point(parent.extrusion,200)
|
|
if parent.lineType!=None: result+=' 6\n%s\n'%parent.lineType
|
|
#TODO: if parent.lineWeight!=None: result+='370\n%s\n'%parent.lineWeight
|
|
if parent.lineTypeScale!=None: result+=' 48\n%s\n'%parent.lineTypeScale
|
|
if parent.thickness!=None: result+=' 39\n%s\n'%parent.thickness
|
|
return result
|
|
|
|
#--------------------------
|
|
class _Entities:
|
|
"""Base class to deal with composed objects."""
|
|
def __dxf__(self):
|
|
return []
|
|
|
|
def __str__(self):
|
|
return ''.join([str(x) for x in self.__dxf__()])
|
|
|
|
#--------------------------
|
|
class _Collection(_Call):
|
|
"""Base class to expose entities methods to main object."""
|
|
def __init__(self,entities=[]):
|
|
self.entities=copy.copy(entities)
|
|
#link entities methods to drawing
|
|
for attr in dir(self.entities):
|
|
if attr[0]!='_':
|
|
attrObject=getattr(self.entities,attr)
|
|
if callable(attrObject):
|
|
setattr(self,attr,attrObject)
|
|
|
|
####2) Constants
|
|
#---color values
|
|
BYBLOCK=0
|
|
BYLAYER=256
|
|
|
|
#---block-type flags (bit coded values, may be combined):
|
|
ANONYMOUS =1 # This is an anonymous block generated by hatching, associative dimensioning, other internal operations, or an application
|
|
NON_CONSTANT_ATTRIBUTES =2 # This block has non-constant attribute definitions (this bit is not set if the block has any attribute definitions that are constant, or has no attribute definitions at all)
|
|
XREF =4 # This block is an external reference (xref)
|
|
XREF_OVERLAY =8 # This block is an xref overlay
|
|
EXTERNAL =16 # This block is externally dependent
|
|
RESOLVED =32 # This is a resolved external reference, or dependent of an external reference (ignored on input)
|
|
REFERENCED =64 # This definition is a referenced external reference (ignored on input)
|
|
|
|
#---mtext flags
|
|
#attachment point
|
|
TOP_LEFT = 1
|
|
TOP_CENTER = 2
|
|
TOP_RIGHT = 3
|
|
MIDDLE_LEFT = 4
|
|
MIDDLE_CENTER = 5
|
|
MIDDLE_RIGHT = 6
|
|
BOTTOM_LEFT = 7
|
|
BOTTOM_CENTER = 8
|
|
BOTTOM_RIGHT = 9
|
|
#drawing direction
|
|
LEFT_RIGHT = 1
|
|
TOP_BOTTOM = 3
|
|
BY_STYLE = 5 #the flow direction is inherited from the associated text style
|
|
#line spacing style (optional):
|
|
AT_LEAST = 1 #taller characters will override
|
|
EXACT = 2 #taller characters will not override
|
|
|
|
#---polyline flags
|
|
CLOSED =1 # This is a closed polyline (or a polygon mesh closed in the M direction)
|
|
CURVE_FIT =2 # Curve-fit vertices have been added
|
|
SPLINE_FIT =4 # Spline-fit vertices have been added
|
|
POLYLINE_3D =8 # This is a 3D polyline
|
|
POLYGON_MESH =16 # This is a 3D polygon mesh
|
|
CLOSED_N =32 # The polygon mesh is closed in the N direction
|
|
POLYFACE_MESH =64 # The polyline is a polyface mesh
|
|
CONTINOUS_LINETYPE_PATTERN =128 # The linetype pattern is generated continuously around the vertices of this polyline
|
|
|
|
#---text flags
|
|
#horizontal
|
|
LEFT = 0
|
|
CENTER = 1
|
|
RIGHT = 2
|
|
ALIGNED = 3 #if vertical alignment = 0
|
|
MIDDLE = 4 #if vertical alignment = 0
|
|
FIT = 5 #if vertical alignment = 0
|
|
#vertical
|
|
BASELINE = 0
|
|
BOTTOM = 1
|
|
MIDDLE = 2
|
|
TOP = 3
|
|
|
|
####3) Classes
|
|
#---entitities -----------------------------------------------
|
|
#--------------------------
|
|
class Arc(_Entity):
|
|
"""Arc, angles in degrees."""
|
|
def __init__(self,center=(0,0,0),radius=1,
|
|
startAngle=0.0,endAngle=90,**common):
|
|
"""Angles in degrees."""
|
|
_Entity.__init__(self,**common)
|
|
self.center=center
|
|
self.radius=radius
|
|
self.startAngle=startAngle
|
|
self.endAngle=endAngle
|
|
def __str__(self):
|
|
return ' 0\nARC\n%s%s\n 40\n%s\n 50\n%s\n 51\n%s\n'%\
|
|
(self._common(),_point(self.center),
|
|
self.radius,self.startAngle,self.endAngle)
|
|
|
|
#-----------------------------------------------
|
|
class Circle(_Entity):
|
|
"""Circle"""
|
|
def __init__(self,center=(0,0,0),radius=1,**common):
|
|
_Entity.__init__(self,**common)
|
|
self.center=center
|
|
self.radius=radius
|
|
def __str__(self):
|
|
return ' 0\nCIRCLE\n%s%s\n 40\n%s\n'%\
|
|
(self._common(),_point(self.center),self.radius)
|
|
|
|
#-----------------------------------------------
|
|
class Face(_Entity):
|
|
"""3dface"""
|
|
def __init__(self,points,**common):
|
|
_Entity.__init__(self,**common)
|
|
while len(points)<4: #fix for r12 format
|
|
points.append(points[-1])
|
|
self.points=points
|
|
|
|
def __str__(self):
|
|
out = ' 0\n3DFACE\n%s%s\n' %(self._common(),_points(self.points))
|
|
#print 'deb:out=', out #-------------------
|
|
return out
|
|
|
|
#-----------------------------------------------
|
|
class Insert(_Entity):
|
|
"""Block instance."""
|
|
def __init__(self,name,point=(0,0,0),
|
|
xscale=None,yscale=None,zscale=None,
|
|
cols=None,colspacing=None,rows=None,rowspacing=None,
|
|
rotation=None,
|
|
**common):
|
|
_Entity.__init__(self,**common)
|
|
self.name=name
|
|
self.point=point
|
|
self.xscale=xscale
|
|
self.yscale=yscale
|
|
self.zscale=zscale
|
|
self.cols=cols
|
|
self.colspacing=colspacing
|
|
self.rows=rows
|
|
self.rowspacing=rowspacing
|
|
self.rotation=rotation
|
|
|
|
def __str__(self):
|
|
result=' 0\nINSERT\n 2\n%s\n%s\n%s\n'%\
|
|
(self.name,self._common(),_point(self.point))
|
|
if self.xscale!=None:result+=' 41\n%s\n'%self.xscale
|
|
if self.yscale!=None:result+=' 42\n%s\n'%self.yscale
|
|
if self.zscale!=None:result+=' 43\n%s\n'%self.zscale
|
|
if self.rotation:result+=' 50\n%s\n'%self.rotation
|
|
if self.cols!=None:result+=' 70\n%s\n'%self.cols
|
|
if self.colspacing!=None:result+=' 44\n%s\n'%self.colspacing
|
|
if self.rows!=None:result+=' 71\n%s\n'%self.rows
|
|
if self.rowspacing!=None:result+=' 45\n%s\n'%self.rowspacing
|
|
return result
|
|
|
|
#-----------------------------------------------
|
|
class Line(_Entity):
|
|
"""Line"""
|
|
def __init__(self,points,**common):
|
|
_Entity.__init__(self,**common)
|
|
self.points=points
|
|
def __str__(self):
|
|
return ' 0\nLINE\n%s%s\n' %(
|
|
self._common(), _points(self.points))
|
|
|
|
|
|
#-----------------------------------------------
|
|
class PolyLine(_Entity):
|
|
def __init__(self,points,org_point=[0,0,0],flag=0,width=None,**common):
|
|
#width = number, or width = list [width_start=None, width_end=None]
|
|
#for 2d-polyline: points = [ [x, y, z, width_start=None, width_end=None, bulge=0 or None], ...]
|
|
#for 3d-polyline: points = [ [x, y, z], ...]
|
|
#for polyface: points = [points_list, faces_list]
|
|
_Entity.__init__(self,**common)
|
|
self.points=points
|
|
self.org_point=org_point
|
|
self.flag=flag
|
|
self.width= 0.0 # dummy value
|
|
if self.flag & POLYFACE_MESH:
|
|
self.polyface=True
|
|
self.points=points[0]
|
|
self.faces=points[1]
|
|
self.p_count=len(self.points)
|
|
self.f_count=len(self.faces)
|
|
elif not self.flag & POLYLINE_3D:
|
|
self.polyline2d = True
|
|
self.polyface = False
|
|
self.faces = [] # dummy value
|
|
if width:
|
|
if type(width)!='list':
|
|
width=[width,width]
|
|
self.width=width
|
|
|
|
def __str__(self):
|
|
result= ' 0\nPOLYLINE\n%s 70\n%s\n' %(self._common(),self.flag)
|
|
#print 'deb: self._common()', self._common() #----------
|
|
result+=' 66\n1\n'
|
|
result+='%s\n' %_point(self.org_point)
|
|
if self.polyface:
|
|
result+=' 71\n%s\n' %self.p_count
|
|
result+=' 72\n%s\n' %self.f_count
|
|
elif self.polyline2d:
|
|
if self.width: result+=' 40\n%s\n 41\n%s\n' %(self.width[0],self.width[1])
|
|
for point in self.points:
|
|
result+=' 0\nVERTEX\n'
|
|
result+=' 8\n%s\n' %self.layer
|
|
result+='%s\n' %_point(point[0:2])
|
|
if self.polyface:
|
|
result+=' 70\n192\n'
|
|
elif self.polyline2d:
|
|
if len(point)>4:
|
|
width1, width2 = point[3], point[4]
|
|
if width1!=None: result+=' 40\n%s\n' %width1
|
|
if width2!=None: result+=' 41\n%s\n' %width2
|
|
if len(point)==6:
|
|
bulge = point[5]
|
|
if bulge: result+=' 42\n%s\n' %bulge
|
|
for face in self.faces:
|
|
result+=' 0\nVERTEX\n'
|
|
result+=' 8\n%s\n' %self.layer
|
|
result+='%s\n' %_point(self.org_point)
|
|
result+=' 70\n128\n'
|
|
result+=' 71\n%s\n' %face[0]
|
|
result+=' 72\n%s\n' %face[1]
|
|
result+=' 73\n%s\n' %face[2]
|
|
if len(face)==4: result+=' 74\n%s\n' %face[3]
|
|
result+=' 0\nSEQEND\n'
|
|
result+=' 8\n%s\n' %self.layer
|
|
return result
|
|
|
|
#-----------------------------------------------
|
|
class Point(_Entity):
|
|
"""Point."""
|
|
def __init__(self,points=None,**common):
|
|
_Entity.__init__(self,**common)
|
|
self.points=points
|
|
def __str__(self): #TODO:
|
|
return ' 0\nPOINT\n%s%s\n' %(self._common(),
|
|
_points(self.points)
|
|
)
|
|
|
|
#-----------------------------------------------
|
|
class Solid(_Entity):
|
|
"""Colored solid fill."""
|
|
def __init__(self,points=None,**common):
|
|
_Entity.__init__(self,**common)
|
|
self.points=points
|
|
def __str__(self):
|
|
return ' 0\nSOLID\n%s%s\n' %(self._common(),
|
|
_points(self.points[:2]+[self.points[3],self.points[2]])
|
|
)
|
|
|
|
|
|
#-----------------------------------------------
|
|
class Text(_Entity):
|
|
"""Single text line."""
|
|
def __init__(self,text='',point=(0,0,0),alignment=None,
|
|
flag=None,height=1,justifyhor=None,justifyver=None,
|
|
rotation=None,obliqueAngle=None,style=None,xscale=None,**common):
|
|
_Entity.__init__(self,**common)
|
|
self.text=text
|
|
self.point=point
|
|
self.alignment=alignment
|
|
self.flag=flag
|
|
self.height=height
|
|
self.justifyhor=justifyhor
|
|
self.justifyver=justifyver
|
|
self.rotation=rotation
|
|
self.obliqueAngle=obliqueAngle
|
|
self.style=style
|
|
self.xscale=xscale
|
|
def __str__(self):
|
|
result= ' 0\nTEXT\n%s%s\n 40\n%s\n 1\n%s\n'%\
|
|
(self._common(),_point(self.point),self.height,self.text)
|
|
if self.rotation: result+=' 50\n%s\n'%self.rotation
|
|
if self.xscale: result+=' 41\n%s\n'%self.xscale
|
|
if self.obliqueAngle: result+=' 51\n%s\n'%self.obliqueAngle
|
|
if self.style: result+=' 7\n%s\n'%self.style
|
|
if self.flag: result+=' 71\n%s\n'%self.flag
|
|
if self.justifyhor: result+=' 72\n%s\n'%self.justifyhor
|
|
#TODO: if self.alignment: result+='%s\n'%_point(self.alignment,1)
|
|
if self.justifyver: result+=' 73\n%s\n'%self.justifyver
|
|
return result
|
|
|
|
#-----------------------------------------------
|
|
class Mtext(Text):
|
|
"""Surrogate for mtext, generates some Text instances."""
|
|
def __init__(self,text='',point=(0,0,0),width=250,spacingFactor=1.5,down=0,spacingWidth=None,**options):
|
|
Text.__init__(self,text=text,point=point,**options)
|
|
if down:spacingFactor*=-1
|
|
self.spacingFactor=spacingFactor
|
|
self.spacingWidth=spacingWidth
|
|
self.width=width
|
|
self.down=down
|
|
def __str__(self):
|
|
texts=self.text.replace('\r\n','\n').split('\n')
|
|
if not self.down:texts.reverse()
|
|
result=''
|
|
x=y=0
|
|
if self.spacingWidth:spacingWidth=self.spacingWidth
|
|
else:spacingWidth=self.height*self.spacingFactor
|
|
for text in texts:
|
|
while text:
|
|
result+='%s\n'%Text(text[:self.width],
|
|
point=(self.point[0]+x*spacingWidth,
|
|
self.point[1]+y*spacingWidth,
|
|
self.point[2]),
|
|
alignment=self.alignment,flag=self.flag,height=self.height,
|
|
justifyhor=self.justifyhor,justifyver=self.justifyver,
|
|
rotation=self.rotation,obliqueAngle=self.obliqueAngle,
|
|
style=self.style,xscale=self.xscale,parent=self
|
|
)
|
|
text=text[self.width:]
|
|
if self.rotation:x+=1
|
|
else:y+=1
|
|
return result[1:]
|
|
|
|
#-----------------------------------------------
|
|
##class _Mtext(_Entity):
|
|
## """Mtext not functioning for minimal dxf."""
|
|
## def __init__(self,text='',point=(0,0,0),attachment=1,
|
|
## charWidth=None,charHeight=1,direction=1,height=100,rotation=0,
|
|
## spacingStyle=None,spacingFactor=None,style=None,width=100,
|
|
## xdirection=None,**common):
|
|
## _Entity.__init__(self,**common)
|
|
## self.text=text
|
|
## self.point=point
|
|
## self.attachment=attachment
|
|
## self.charWidth=charWidth
|
|
## self.charHeight=charHeight
|
|
## self.direction=direction
|
|
## self.height=height
|
|
## self.rotation=rotation
|
|
## self.spacingStyle=spacingStyle
|
|
## self.spacingFactor=spacingFactor
|
|
## self.style=style
|
|
## self.width=width
|
|
## self.xdirection=xdirection
|
|
## def __str__(self):
|
|
## input=self.text
|
|
## text=''
|
|
## while len(input)>250:
|
|
## text+='3\n%s\n'%input[:250]
|
|
## input=input[250:]
|
|
## text+='1\n%s\n'%input
|
|
## result= '0\nMTEXT\n%s\n%s\n40\n%s\n41\n%s\n71\n%s\n72\n%s%s\n43\n%s\n50\n%s\n'%\
|
|
## (self._common(),_point(self.point),self.charHeight,self.width,
|
|
## self.attachment,self.direction,text,
|
|
## self.height,
|
|
## self.rotation)
|
|
## if self.style:result+='7\n%s\n'%self.style
|
|
## if self.xdirection:result+='%s\n'%_point(self.xdirection,1)
|
|
## if self.charWidth:result+='42\n%s\n'%self.charWidth
|
|
## if self.spacingStyle:result+='73\n%s\n'%self.spacingStyle
|
|
## if self.spacingFactor:result+='44\n%s\n'%self.spacingFactor
|
|
## return result
|
|
|
|
#---tables ---------------------------------------------------
|
|
#-----------------------------------------------
|
|
class Block(_Collection):
|
|
"""Use list methods to add entities, eg append."""
|
|
def __init__(self,name,layer='0',flag=0,base=(0,0,0),entities=[]):
|
|
self.entities=copy.copy(entities)
|
|
_Collection.__init__(self,entities)
|
|
self.layer=layer
|
|
self.name=name
|
|
self.flag=0
|
|
self.base=base
|
|
def __str__(self): #TODO:
|
|
e=''.join([str(x)for x in self.entities])
|
|
return ' 0\nBLOCK\n 8\n%s\n 2\n%s\n 70\n%s\n%s\n 3\n%s\n%s 0\nENDBLK\n'%\
|
|
(self.layer,self.name.upper(),self.flag,_point(self.base),self.name.upper(),e)
|
|
|
|
#-----------------------------------------------
|
|
class Layer(_Call):
|
|
"""Layer"""
|
|
def __init__(self,name='pydxf',color=7,lineType='continuous',flag=64):
|
|
self.name=name
|
|
self.color=color
|
|
self.lineType=lineType
|
|
self.flag=flag
|
|
def __str__(self):
|
|
return ' 0\nLAYER\n 2\n%s\n 70\n%s\n 62\n%s\n 6\n%s\n'%\
|
|
(self.name.upper(),self.flag,self.color,self.lineType)
|
|
|
|
#-----------------------------------------------
|
|
class LineType(_Call):
|
|
"""Custom linetype"""
|
|
def __init__(self,name='continuous',description='Solid line',elements=[],flag=64):
|
|
# TODO: Implement lineType elements
|
|
self.name=name
|
|
self.description=description
|
|
self.elements=copy.copy(elements)
|
|
self.flag=flag
|
|
def __str__(self):
|
|
return ' 0\nLTYPE\n 2\n%s\n 70\n%s\n 3\n%s\n 72\n65\n 73\n%s\n 40\n0.0\n'%\
|
|
(self.name.upper(),self.flag,self.description,len(self.elements))
|
|
|
|
#-----------------------------------------------
|
|
class Style(_Call):
|
|
"""Text style"""
|
|
def __init__(self,name='standard',flag=0,height=0,widthFactor=40,obliqueAngle=50,
|
|
mirror=0,lastHeight=1,font='arial.ttf',bigFont=''):
|
|
self.name=name
|
|
self.flag=flag
|
|
self.height=height
|
|
self.widthFactor=widthFactor
|
|
self.obliqueAngle=obliqueAngle
|
|
self.mirror=mirror
|
|
self.lastHeight=lastHeight
|
|
self.font=font
|
|
self.bigFont=bigFont
|
|
def __str__(self):
|
|
return ' 0\nSTYLE\n 2\n%s\n 70\n%s\n 40\n%s\n 41\n%s\n 50\n%s\n 71\n%s\n 42\n%s\n 3\n%s\n 4\n%s\n'%\
|
|
(self.name.upper(),self.flag,self.flag,self.widthFactor,
|
|
self.obliqueAngle,self.mirror,self.lastHeight,
|
|
self.font.upper(),self.bigFont.upper())
|
|
|
|
#-----------------------------------------------
|
|
class View(_Call):
|
|
def __init__(self,name,flag=0,width=1,height=1,center=(0.5,0.5),
|
|
direction=(0,0,1),target=(0,0,0),lens=50,
|
|
frontClipping=0,backClipping=0,twist=0,mode=0):
|
|
self.name=name
|
|
self.flag=flag
|
|
self.width=width
|
|
self.height=height
|
|
self.center=center
|
|
self.direction=direction
|
|
self.target=target
|
|
self.lens=lens
|
|
self.frontClipping=frontClipping
|
|
self.backClipping=backClipping
|
|
self.twist=twist
|
|
self.mode=mode
|
|
def __str__(self):
|
|
return ' 0\nVIEW\n 2\n%s\n 70\n%s\n 40\n%s\n%s\n 41\n%s\n%s\n%s\n 42\n%s\n 43\n%s\n 44\n%s\n 50\n%s\n 71\n%s\n'%\
|
|
(self.name,self.flag,self.height,_point(self.center),self.width,
|
|
_point(self.direction,1),_point(self.target,2),self.lens,
|
|
self.frontClipping,self.backClipping,self.twist,self.mode)
|
|
|
|
#-----------------------------------------------
|
|
def ViewByWindow(name,leftBottom=(0,0),rightTop=(1,1),**options):
|
|
width=abs(rightTop[0]-leftBottom[0])
|
|
height=abs(rightTop[1]-leftBottom[1])
|
|
center=((rightTop[0]+leftBottom[0])*0.5,(rightTop[1]+leftBottom[1])*0.5)
|
|
return View(name=name,width=width,height=height,center=center,**options)
|
|
|
|
#---drawing
|
|
#-----------------------------------------------
|
|
class Drawing(_Collection):
|
|
"""Dxf drawing. Use append or any other list methods to add objects."""
|
|
def __init__(self,insbase=(0.0,0.0,0.0),extmin=(0.0,0.0,0.0),extmax=(0.0,0.0,0.0),
|
|
layers=[Layer()],linetypes=[LineType()],styles=[Style()],blocks=[],
|
|
views=[],entities=None,fileName='test.dxf'):
|
|
# TODO: replace list with None,arial
|
|
if not entities:
|
|
entities=[]
|
|
_Collection.__init__(self,entities)
|
|
self.insbase=insbase
|
|
self.extmin=extmin
|
|
self.extmax=extmax
|
|
self.layers=copy.copy(layers)
|
|
self.linetypes=copy.copy(linetypes)
|
|
self.styles=copy.copy(styles)
|
|
self.views=copy.copy(views)
|
|
self.blocks=copy.copy(blocks)
|
|
self.fileName=fileName
|
|
#private
|
|
#self.acadver='9\n$ACADVER\n1\nAC1006\n'
|
|
self.acadver=' 9\n$ACADVER\n 1\nAC1009\n'
|
|
"""DXF AutoCAD-Release format codes
|
|
AC1021 2008, 2007
|
|
AC1018 2006, 2005, 2004
|
|
AC1015 2002, 2000i, 2000
|
|
AC1014 R14,14.01
|
|
AC1012 R13
|
|
AC1009 R12,11
|
|
AC1006 R10
|
|
AC1004 R9
|
|
AC1002 R2.6
|
|
AC1.50 R2.05
|
|
"""
|
|
|
|
def _name(self,x):
|
|
"""Helper function for self._point"""
|
|
return ' 9\n$%s\n' %x.upper()
|
|
|
|
def _point(self,name,x):
|
|
"""Point setting from drawing like extmin,extmax,..."""
|
|
return '%s%s' %(self._name(name),_point(x))
|
|
|
|
def _section(self,name,x):
|
|
"""Sections like tables,blocks,entities,..."""
|
|
if x: xstr=''.join(x)
|
|
else: xstr=''
|
|
return ' 0\nSECTION\n 2\n%s\n%s 0\nENDSEC\n'%(name.upper(),xstr)
|
|
|
|
def _table(self,name,x):
|
|
"""Tables like ltype,layer,style,..."""
|
|
if x: xstr=''.join(x)
|
|
else: xstr=''
|
|
return ' 0\nTABLE\n 2\n%s\n 70\n%s\n%s 0\nENDTAB\n'%(name.upper(),len(x),xstr)
|
|
|
|
def __str__(self):
|
|
"""Returns drawing as dxf string."""
|
|
header=[self.acadver]+[self._point(attr,getattr(self,attr))+'\n' for attr in _HEADER_POINTS]
|
|
header=self._section('header',header)
|
|
|
|
tables=[self._table('ltype',[str(x) for x in self.linetypes]),
|
|
self._table('layer',[str(x) for x in self.layers]),
|
|
self._table('style',[str(x) for x in self.styles]),
|
|
self._table('view',[str(x) for x in self.views]),
|
|
]
|
|
tables=self._section('tables',tables)
|
|
|
|
blocks=self._section('blocks',[str(x) for x in self.blocks])
|
|
|
|
entities=self._section('entities',[str(x) for x in self.entities])
|
|
|
|
all=''.join([header,tables,blocks,entities,' 0\nEOF\n'])
|
|
return all
|
|
|
|
def saveas(self,fileName):
|
|
self.fileName=fileName
|
|
self.save()
|
|
|
|
def save(self):
|
|
test=open(self.fileName,'w')
|
|
test.write(str(self))
|
|
test.close()
|
|
|
|
|
|
#---extras
|
|
#-----------------------------------------------
|
|
class Rectangle(_Entity):
|
|
"""Rectangle, creates lines."""
|
|
def __init__(self,point=(0,0,0),width=1,height=1,solid=None,line=1,**common):
|
|
_Entity.__init__(self,**common)
|
|
self.point=point
|
|
self.width=width
|
|
self.height=height
|
|
self.solid=solid
|
|
self.line=line
|
|
def __str__(self):
|
|
result=''
|
|
points=[self.point,(self.point[0]+self.width,self.point[1],self.point[2]),
|
|
(self.point[0]+self.width,self.point[1]+self.height,self.point[2]),
|
|
(self.point[0],self.point[1]+self.height,self.point[2]),self.point]
|
|
if self.solid:
|
|
result+= Solid(points=points[:-1],parent=self.solid)
|
|
if self.line:
|
|
for i in range(4):
|
|
result+= Line(points=[points[i],points[i+1]],parent=self)
|
|
return result[1:]
|
|
|
|
#-----------------------------------------------
|
|
class LineList(_Entity):
|
|
"""Like polyline, but built of individual lines."""
|
|
def __init__(self,points=[],org_point=[0,0,0],closed=0,**common):
|
|
_Entity.__init__(self,**common)
|
|
self.closed=closed
|
|
self.points=copy.copy(points)
|
|
def __str__(self):
|
|
if self.closed:points=self.points+[self.points[0]]
|
|
else: points=self.points
|
|
result=''
|
|
for i in range(len(points)-1):
|
|
result+= Line(points=[points[i],points[i+1]],parent=self)
|
|
return result[1:]
|
|
|
|
#-----------------------------------------------------
|
|
def test():
|
|
#Blocks
|
|
b=Block('test')
|
|
b.append(Solid(points=[(0,0,0),(1,0,0),(1,1,0),(0,1,0)],color=1))
|
|
b.append(Arc(center=(1,0,0),color=2))
|
|
|
|
#Drawing
|
|
d=Drawing()
|
|
#tables
|
|
d.blocks.append(b) #table blocks
|
|
d.styles.append(Style()) #table styles
|
|
d.views.append(View('Normal')) #table view
|
|
d.views.append(ViewByWindow('Window',leftBottom=(1,0),rightTop=(2,1))) #idem
|
|
|
|
#entities
|
|
d.append(Circle(center=(1,1,0),color=3))
|
|
d.append(Face(points=[(0,0,0),(1,0,0),(1,1,0),(0,1,0)],color=4))
|
|
d.append(Insert('test',point=(3,3,3),cols=5,colspacing=2))
|
|
d.append(Line(points=[(0,0,0),(1,1,1)]))
|
|
d.append(Mtext('Click on Ads\nmultiple lines with mtext',point=(1,1,1),color=5,rotation=90))
|
|
d.append(Text('Please donate!',point=(3,0,1)))
|
|
d.append(Rectangle(point=(2,2,2),width=4,height=3,color=6,solid=Solid(color=2)))
|
|
d.append(Solid(points=[(4,4,0),(5,4,0),(7,8,0),(9,9,0)],color=3))
|
|
d.append(PolyLine(points=[(1,1,1),(2,1,1),(2,2,1),(1,2,1)],closed=1,color=1))
|
|
|
|
#d.saveas('c:\\test.dxf')
|
|
d.saveas('test.dxf')
|
|
|
|
|
|
#-----------------------------------------------------
|
|
if __name__=='__main__':
|
|
if not copy:
|
|
Draw.PupMenu('Error%t|This script requires a full python install')
|
|
else: main()
|
|
|