def createpallets(spacing):
##### Pallets
pallet = dxf.block(name='pallet')
dwg.blocks.add(pallet)
blockfaces(pallet, palx, paly, palz, 0, 0, 0)
# Outermost loop for creating levels
for m in range(levels):
levelheight = datz + palz + loadz + lift
lh = levelheight * m
# Outer loop to create all the aisles
for l in range(aisles):
# Calc distance between aisles
#spacing = (2 * maxy) + aislew + backgap + (2 * (maxy + deepgap) * ydeep)
aisle2 = spacing * l
# Inner loop to create one aisle
for k in range(bays):
# calculate bay length
blen = upx + ((bay - 1) * upgap) + (bay * maxx) + ((bay - 1) * palgap)
blength = blen * k
# create first bay
for i in range(bay):
blockref = dxf.insert(blockname='pallet', layer='CLT_PLT_Pallet', insert=(upx+upgap+(maxx/2)-(palx/2)+(i*(maxx + palgap))+blength,(aislew/2)+(maxy/2)-(paly/2)+aisle2,lapproach+lh))
dwg.add(blockref)
# create opposite side
for j in range(bay):
blockref = dxf.insert(blockname='pallet', layer='CLT_PLT_Pallet', insert=(upx+upgap+(maxx/2)-(palx/2)+(j*(maxx + palgap))+blength,0-(aislew/2)-(maxy/2)-(paly/2)+aisle2,lapproach+lh))
dwg.add(blockref)
def createuprights(spacing):
##### Uprights
upright = dxf.block(name='upright')
dwg.blocks.add(upright)
# calculate upright height
upz = lapproach + (levels * (palz + loadz + lift + datz)) - datz - lift + uapproach
blockfaces(upright, upx, upy, upz, 0, 0, 0)
# Outer loop to create all the aisles
for l in range(aisles):
# Calc distance between aisles
#spacing = (2 * maxy) + aislew + backgap + (2 * (maxy + deepgap) * ydeep)
aisle2 = spacing * l
# Inner loop to create one aisle
for k in range(bays+1):
# calculate bay length
blen = upx + ((bay - 1) * upgap) + (bay * maxx) + ((bay - 1) * palgap)
blength = blen * k
# create inner upright
blockref1 = dxf.insert(blockname='upright', layer='CLT_RAK_Pallet_Rack', insert=((blength,(aislew/2)+(maxy/2)+(up2up/2)+aisle2, 0)))
dwg.add(blockref1)
# create outer upright
blockref2 = dxf.insert(blockname='upright', layer='CLT_RAK_Pallet_Rack', insert=((blength,(aislew/2)+(maxy/2)-(up2up/2)-upy+aisle2, 0)))
dwg.add(blockref2)
# create inner upright (opposite)
blockref1 = dxf.insert(blockname='upright', layer='CLT_RAK_Pallet_Rack', insert=((blength,0-(aislew/2)-(maxy/2)+(up2up/2)+aisle2, 0)))
dwg.add(blockref1)
# create outer upright (opposite)
blockref2 = dxf.insert(blockname='upright', layer='CLT_RAK_Pallet_Rack', insert=((blength,0-(aislew/2)-(maxy/2)-(up2up/2)-upy+aisle2, 0)))
dwg.add(blockref2)
def createdat(spacing):
##### Down Aisle Ties
tie = dxf.block(name='tie')
dwg.blocks.add(tie)
# calculate tie length
datx = ((bays + 1) * upx) + (bays * (((bay - 1) * upgap) + (bay * maxx) + ((bay - 1) * palgap)))
blockfaces(tie, datx, daty, datz, 0, 0, 0)
# Create ties for all levels
for m in range(levels):
levelheight = datz + palz + loadz + lift
lh = levelheight * m
# Outer loop to create all the aisles
for l in range(aisles):
# Calc distance between aisles
#spacing = (2 * maxy) + aislew + backgap + (2 * (maxy + deepgap) * ydeep)
aisle2 = spacing * l
# create outer tie
blockref1 = dxf.insert(blockname='tie', layer='CLT_RAK_Pallet_Rack', insert=((0,(aislew/2)+(maxy/2)+(up2up/2)+upy+aisle2, lapproach-datz+lh)))
dwg.add(blockref1)
# create inter tie
blockref2 = dxf.insert(blockname='tie', layer='CLT_RAK_Pallet_Rack', insert=((0,(aislew/2)+(maxy/2)-(up2up/2)-upy-daty+aisle2, lapproach-datz+lh)))
dwg.add(blockref2)
# create outer tie (opposite)
blockref1 = dxf.insert(blockname='tie', layer='CLT_RAK_Pallet_Rack', insert=((0,0-(aislew/2)-(maxy/2)-(up2up/2)-upy-daty+aisle2, lapproach-datz+lh)))
dwg.add(blockref1)
# create inter tie (opposite)
blockref2 = dxf.insert(blockname='tie', layer='CLT_RAK_Pallet_Rack', insert=((0,0-(aislew/2)-(maxy/2)+(up2up/2)+upy+aisle2, lapproach-datz+lh)))
dwg.add(blockref2)
def contacts_parallel(drawing, blockname, layer, color, taper_point,
taper_length, taper_width, taper_before_track,
*contact_coords): # contacts the nanowire in parallel
block_temp = dxf.block("block_temp", layer=layer)
drawing.blocks.add(block_temp)
taper = dxf.polyline(layer=layer)
taper.add_vertices([(0, -taper_point / 2), (0, taper_point / 2),
(-taper_length, taper_width / 2),
(-taper_length, -taper_width / 2)])
taper.close(True)
#drawing.add(taper)
block_temp.add(taper)
block_temp.add(
dxf.rectangle((-taper_length - taper_before_track, -taper_width / 2),
taper_before_track,
taper_width,
color=color,
rotation=0,
layer=layer)) #contact 1
#block.add(dxf.rectangle((-taper_length-taper_before_track,-taper_width/2), taper_before_track, taper_width,
# color = color, rotation = 0, layer = layer)) #contact 2
block = dxf.block(blockname, layer=layer)
block_ref = dxf.insert(blockname='block_temp',
insert=(contact_coords[0], 0),
columns=1,
rows=1,
colspacing=0,
rowspacing=0,
color=color,
rotation=0)
block_ref1 = dxf.insert(blockname='block_temp',
insert=(contact_coords[1], 0),
columns=1,
rows=1,
colspacing=0,
rowspacing=0,
color=color,
rotation=180)
block.add(block_ref)
block.add(block_ref1)
return block
def mark1000(self, markHeight, start, stop, layer):
width = markHeight / 4
#default spacing is
for i in range(start, stop + 1):
n = i - start
self.drawing.add(
dxf.insert('0' + str(n // 100),
insert=self.chipSpace(
vadd((width, width), self.chipPts[i])),
layer=self.lyr(layer)))
self.drawing.add(
dxf.insert('0' + str(n % 100 // 10),
insert=self.chipSpace(
vadd((width * 5, width), self.chipPts[i])),
layer=self.lyr(layer)))
self.drawing.add(
dxf.insert('0' + str(n % 10),
insert=self.chipSpace(
vadd((width * 9, width), self.chipPts[i])),
layer=self.lyr(layer)))
def add_anonymous_block(self, entity, layer="0", typechar='U',
basepoint=(0, 0), insert=(0, 0)):
""" Insert entity (can be a DXFList) as anonymous block into drawing.
"""
blockname = self.anonymous_blockname(typechar)
block = DXFEngine.block(blockname, basepoint=basepoint,
flags=const.BLK_ANONYMOUS)
block.add(entity)
self.blocks.add(block)
insert = DXFEngine.insert(blockname, insert=insert, layer=layer)
self.add(insert)
return blockname
def position_tgates(new_blockname, blockname, layer, color, *tgate_coords):
block = dxf.block(new_blockname, layer=layer)
for tgate in tgate_coords:
tgate_ref_temp = dxf.insert(blockname=blockname,
insert=(tgate, 0),
columns=1,
rows=1,
colspacing=0,
rowspacing=0,
color=color)
block.add(tgate_ref_temp)
return block
def position_plunger(new_blockname, blockname, layer, color, *plunger_coords):
block = dxf.block(new_blockname, layer=layer)
for plunger in plunger_coords:
plunger_ref_temp = dxf.insert(blockname=blockname,
insert=(plunger, 0),
columns=1,
rows=1,
colspacing=0,
rowspacing=0,
color=color)
block.add(plunger_ref_temp)
return block
def add_xref(self, filepath, insert=(0., 0., 0.), layer='0'):
""" Create a simple XREF reference, `filepath` is the referenced
drawing and `insert` is the insertion point.
"""
def normblockname(blockname):
for char in ' :/\\.':
blockname = blockname.replace(char, '')
return blockname
dirname, filename = os.path.split(filepath)
blockname = normblockname(filename)
xref = DXFEngine.block(name=blockname, flags=const.BLK_XREF, xref=filepath)
self.blocks.add(xref)
self.add(DXFEngine.insert(blockname, insert, layer=layer))
def add_xref(self, filepath, insert=(0., 0., 0.), layer='0'):
""" Create a simple XREF reference, `filepath` is the referenced
drawing and `insert` is the insertion point.
"""
def normblockname(blockname):
for char in ' :/\\.':
blockname = blockname.replace(char, '')
return blockname
dirname, filename = os.path.split(filepath)
blockname = normblockname(filename)
xref = DXFEngine.block(name=blockname, flags=const.BLK_XREF, xref=filepath)
self.blocks.add(xref)
self.add(DXFEngine.insert(blockname, insert, layer=layer))
def position_parallel_contacts(new_blockname, blockname, layer, color,
rotation, *contact_coords):
block = dxf.block(new_blockname, layer=layer)
for contact in contact_coords:
contact_ref_temp = dxf.insert(blockname=blockname,
insert=(contact, 0),
columns=1,
rows=1,
colspacing=0,
rowspacing=0,
color=color,
rotation=rotation)
block.add(contact_ref_temp)
return block
def create_cad():
'''
:return: a cad file(.dxf)
'''
global cad_name
project_list = []
excel_name = input("请输入Excel文件名称(粘贴复制无后辍哦~): ")
num_projects = int(input("请输入写入项目数(同Excel但除XY): "))
for project_num in range(1, num_projects + 1):
pk_num = int(input("请输入项目%s所在列号：" % project_num))
project_list.append(pk_num)
pk_x_cood = int(input("请输入排口横坐标所在列号："))
pk_y_cood = int(input("请输入排口纵坐标所在列号："))
cad_name = input("请输入要保存的CAD文件名称：")
# draw a cad picture
drawing = dxf.drawing(os.getcwd() + "/%s.dxf" % cad_name)
# read excel datas
wb = load_workbook(os.getcwd() + "/" + excel_name + ".xlsx")
ws = wb.active
for row in ws.rows:
for project_column in project_list:
if str(row[pk_x_cood - 1].value).replace(
".", "").isdigit() == True and str(
row[pk_y_cood - 1].value).replace(
".", "").isdigit() == True:
print(row[project_column - 1].value, row[pk_x_cood - 1].value,
row[pk_y_cood - 1].value)
x_cood = float(row[pk_x_cood - 1].value)
y_cood = float(row[pk_y_cood - 1].value)
pai_num = row[project_column - 1].value
circle = dxf.circle(2.0)
circle['layer'] = 'paikou'
circle['color'] = 2
text = dxf.text(pai_num,
(x_cood, y_cood -
1.35 * project_list.index(project_column)),
height=1.207)
text['layer'] = 'paikou'
text['color'] = 2
block = dxf.block(name='paikou')
block.add(circle)
drawing.blocks.add(block)
blockref = dxf.insert(blockname='paikou',
insert=(x_cood, y_cood))
drawing.add(blockref)
drawing.add(text)
drawing.save()
def use_xref_manual(drawingname, xrefname):
dwg = get_host_dwg(drawingname)
dwg.add_layer('XREF')
# AutoCAD 2010 can not resolve XREFS in DXF R12 Format :-(,
# or with 'dxfwrite' created drawings are malformed XREFS?
# define xref
# you have control over flags
flag = dxfwrite.const.BLK_XREF
xref = dxf.block(name='xref', flags=flag, xref=xrefname)
dwg.blocks.add(xref)
# using xref
# you have control over layer
dwg.add(dxf.insert('xref', layer='XREF'))
dwg.save()
def use_xref_manual(drawingname, xrefname):
dwg = get_host_dwg(drawingname)
dwg.add_layer('XREF')
# AutoCAD 2010 can not resolve XREFS in DXF R12 Format :-(,
# or with 'dxfwrite' created drawings are malformed XREFS?
# define xref
# you have control over flags
flag = dxfwrite.const.BLK_XREF
xref = dxf.block(name='xref', flags=flag ,xref=xrefname)
dwg.blocks.add(xref)
# using xref
# you have control over layer
dwg.add(dxf.insert('xref', layer='XREF'))
dwg.save()
def create_cad():
'''
:return: a cad file(.dxf)
'''
global cad_name
excel_name = input("\033[1;32m请输入Excel文件名称：（粘贴复制哦~）\033[0m")
pk_num = int(input("\033[1;32m请输入排口编号所在列号：\033[0m"))
pk_x_cood = int(input("\033[1;32m请输入排口横坐标所在列号：\033[0m"))
pk_y_cood = int(input("\033[1;32m请输入排口纵坐标所在列号：\033[0m"))
cad_name = input("请输入要保存的CAD文件名称：")
# draw a cad picture
drawing = dxf.drawing(os.getcwd() + "/%s.dxf" % cad_name)
# read excel datas
wb = load_workbook(os.getcwd() + "/" + excel_name + ".xlsx")
ws = wb.active
for row in ws.rows:
if row[pk_num-1].value != None and row[pk_x_cood-1].value != None and row[pk_y_cood-1].value != None \
and is_number(row[pk_x_cood-1].value) == True and is_number(row[pk_y_cood-1].value) == True:
print(row[pk_num - 1].value, row[pk_x_cood - 1].value,
row[pk_y_cood - 1].value)
x_cood = float(row[pk_x_cood - 1].value)
y_cood = float(row[pk_y_cood - 1].value)
pai_num = row[pk_num - 1].value
circle = dxf.circle(2.0)
circle['layer'] = 'paikou'
circle['color'] = 2
text = dxf.text(pai_num, (x_cood, y_cood), height=1.207)
text['layer'] = 'paikou'
text['color'] = 2
block = dxf.block(name='paikou')
block.add(circle)
drawing.blocks.add(block)
blockref = dxf.insert(blockname='paikou', insert=(x_cood, y_cood))
drawing.add(blockref)
drawing.add(text)
drawing.save()
def cblock(bname,x,y,z,lx,ly,lz):
# create a block
board1 = dxf.block(name=bname)
drawing.blocks.add(board1)
# create 3dfaces for cube
face1 = dxf.face3d([(0,0,0),(x,0,0),(x,y,0),(0,y,0)])
face2 = dxf.face3d([(0,0,0),(x,0,0),(x,0,z),(0,0,z)])
face3 = dxf.face3d([(0,0,0),(0,0,z),(0,y,z),(0,y,0)])
face4 = dxf.face3d([(x,0,0),(x,0,z),(x,y,z),(x,y,0)])
face5 = dxf.face3d([(0,y,z),(0,0,z),(x,0,z),(x,y,z)])
face6 = dxf.face3d([(0,y,0),(x,y,0),(x,y,z),(0,y,z)])
# add 3dface to block
board1.add(face1)
board1.add(face2)
board1.add(face3)
board1.add(face4)
board1.add(face5)
board1.add(face6)
# insert the block-create ref, then add to drawing
blockref = dxf.insert(blockname=bname, insert=(lx,ly,lz))
drawing.add(blockref)
import xlrd, dxfwrite
from dxfwrite import DXFEngine as dxf
# draw a cad picture
drawing = dxf.drawing('排口坐标.dxf')
# read excel datas
data = xlrd.open_workbook('1.xls')
num_sheets = len(data.sheets())
for n in range(num_sheets):
table = data.sheets()[n]
nrows = table.nrows
for i in range(2, nrows):
x_cood = float(table.cell(i, 2).value)
y_cood = float(table.cell(i, 3).value)
pai_num = table.cell(i, 1).value
circle = dxf.circle(2.0)
circle['layer'] = 'paikou'
circle['color'] = 2
text = dxf.text(pai_num, (y_cood, x_cood), height=1.207)
text['layer'] = 'paikou'
text['color'] = 2
block = dxf.block(name='paikou')
block.add(circle)
drawing.blocks.add(block)
blockref = dxf.insert(blockname='paikou', insert=(y_cood, x_cood))
drawing.add(blockref)
drawing.add(text)
drawing.save()
#makes the elionix block
ame = alignment_marker.elionix_alignment_marker(layer0, w_e, pw_e, ph_e, ts_e, 0, 0)
drawing.blocks.add(ame)
#makes the raith block
amr = alignment_marker.raith_alignment_marker(layer0, w_r, pw_r, 0, 0)
drawing.blocks.add(amr)
#makes the vistec block
amv = alignment_marker.vistec_alignment_marker(layer0, h_v, w_v, 0, 0)
drawing.blocks.add(amv)
#ADDING ELIONIX BLOCK
am_e_x = [-die_width/2+align_distance+w_e/2, -die_width/2+align_distance+w_e/2] # defining the coordinates of the positions of the alignment blocks
am_e_y = [-die_length/2+align_distance+w_e/2, +die_length/2-align_distance-am_e_gridheight+w_e/2]
ae_ref = dxf.insert(blockname='alignmentmarker_elionix', insert=(am_e_x[0],am_e_y[0]), columns = no_x_align , rows = no_y_align,
colspacing = w_e+align_space_e, rowspacing = w_e+ align_space_e, layer = layer0, color =am_colour) #bot left
ae_ref1 = dxf.insert(blockname='alignmentmarker_elionix', insert=(am_e_x[1],am_e_y[1]), columns = no_x_align , rows = no_y_align,
colspacing = w_e+align_space_e, rowspacing = w_e+ align_space_e, layer = layer0, color =am_colour) # top left
#ADD THE ELIONIX ORIENTATION SQUARES TO EACH OF THE ALIGNMENT MARKERS
#how to make sure the orientation of the alignment markers is correct
orient_marker_size = (w_e-2*ph_e-ts_e)/8
orient_marker_coord = -(w_e-2*ph_e-ts_e)/4-ts_e/2-orient_marker_size/2
ame_orient = dxf.block("ame_orient", layer=layer0)
ame_orient.add(dxf.rectangle((cc[0]+orient_marker_coord,cc[1]+orient_marker_coord,0),
orient_marker_size,orient_marker_size,color = am_colour, rotation = 0, layer = layer0))
ame_orient.add(dxf.rectangle((cc[0]+orient_marker_coord,cc[1]+(w_e+align_space_e)*(no_y_align-1)+orient_marker_coord+ts_e+(w_e-2*ph_e-ts_e)/2,0),
orient_marker_size,orient_marker_size,color = am_colour, rotation = 0, layer = layer0))
ame_orient.add(dxf.rectangle((cc[0]+(w_e+align_space_e)*(no_x_align-1)+orient_marker_coord+ts_e+(w_e-2*ph_e-ts_e)/2,cc[1]+orient_marker_coord,0),
def DicingBorder(self,
maxpts=0,
minpts=0,
thin=5,
thick=20,
short=40,
long=100,
dash=400,
layer='MARKERS'):
'''
# maxpts: where in chip list to stop putting a dicing border
# minpts: where in chip list to start putting dicing border
# thin:5 #thin section of crosshair
# thick:20 #thick section of crosshair AND dash thickness
# short:40 #short section of crosshair
# long:100 #long section of crosshair
# dash:400 #spacing between dashes
'''
if maxpts < 0:
maxpts = len(self.chipPts) + maxpts
#determine filling
bg = self.bg(layer)
offsetX = ((self.chipX - 2 * short - 2 * long) % (dash) + dash) / 2
offsetY = ((self.chipY - 2 * short - 2 * long) % (dash) + dash) / 2
border = dxf.block('DICINGBORDER')
border.add(dxf.rectangle((0, 0), short + thin, thin, bgcolor=bg))
border.add(dxf.rectangle((short + thin, 0), long, thick, bgcolor=bg))
border.add(dxf.rectangle((0, thin), thin, short, bgcolor=bg))
border.add(dxf.rectangle((0, thin + short), thick, long, bgcolor=bg))
for x in range(int(short + long),
int(self.chipX - short - long - dash), dash):
border.add(
dxf.rectangle((x + offsetX, 0), thick, thick, bgcolor=bg))
border.add(
dxf.rectangle((self.chipX, 0), -short - thin, thin, bgcolor=bg))
border.add(
dxf.rectangle((self.chipX - short - thin, 0),
-long,
thick,
bgcolor=bg))
border.add(dxf.rectangle((self.chipX, thin), -thin, short, bgcolor=bg))
border.add(
dxf.rectangle((self.chipX, thin + short), -thick, long,
bgcolor=bg))
for y in range(int(short + long),
int(self.chipY - short - long - dash), dash):
border.add(
dxf.rectangle((0, y + offsetY), thick, thick, bgcolor=bg))
border.add(
dxf.rectangle((0, self.chipY), short + thin, -thin, bgcolor=bg))
border.add(
dxf.rectangle((short + thin, self.chipY), long, -thick,
bgcolor=bg))
border.add(
dxf.rectangle((0, -thin + self.chipY), thin, -short, bgcolor=bg))
border.add(
dxf.rectangle((0, -thin - short + self.chipY),
thick,
-long,
bgcolor=bg))
for x in range(int(short + long),
int(self.chipX - short - long - dash), dash):
border.add(
dxf.rectangle((x + offsetX - thick, self.chipY),
thick,
-thick,
bgcolor=bg))
border.add(
dxf.rectangle((self.chipX, self.chipY),
-short - thin,
-thin,
bgcolor=bg))
border.add(
dxf.rectangle((self.chipX - short - thin, self.chipY),
-long,
-thick,
bgcolor=bg))
border.add(
dxf.rectangle((self.chipX, -thin + self.chipY),
-thin,
-short,
bgcolor=bg))
border.add(
dxf.rectangle((self.chipX, -thin - short + self.chipY),
-thick,
-long,
bgcolor=bg))
for y in range(int(short + long),
int(self.chipY - short - long - dash), dash):
border.add(
dxf.rectangle((self.chipX, y + offsetY - thick),
-thick,
thick,
bgcolor=bg))
self.drawing.blocks.add(border)
for index, pt in enumerate(self.chipPts):
if (maxpts == 0 or index < maxpts) and index >= minpts:
self.drawing.add(
dxf.insert('DICINGBORDER',
insert=(pt[0], pt[1]),
layer=self.lyr(layer)))
face5 = dxf.face3d([(lx,y+ly,z+lz),(lx,ly,z+lz),(x+lx,ly,z+lz),(x+lx,y+ly,z+lz)])
face6 = dxf.face3d([(lx,y+ly,lz),(x+lx,y+ly,lz),(x+lx,y+ly,z+lz),(lx,y+ly,z+lz)])
# add 3dface to block
bname.add(face1)
bname.add(face2)
bname.add(face3)
bname.add(face4)
bname.add(face5)
bname.add(face6)
# Block adding boilerplate, spaces in name not OK
pallet = dxf.block(name='Europallet')
drawing.blocks.add(pallet)
palref = dxf.insert(blockname='Europallet', insert=(0,0,0))
# Create a Euro pallet by adding faces to one block
# Make bottom boards
cblock(pallet, 100, 1200, 22, 0,0,0)
cblock(pallet, 145, 1200, 22, 327.5, 0, 0)
cblock(pallet, 100, 1200, 22, 700, 0, 0)
#make blocks
cblock(pallet, 100, 145, 78, 0, 0, 22)
cblock(pallet, 100, 145, 78, 0, 527.5, 22)
cblock(pallet, 100, 145, 78, 0, 1055, 22)
cblock(pallet, 145, 145, 78, 327.5, 0, 22)
drawing.add(palref)
def writeChip(self, chip, index):
#insert a chip at specified index
self.drawing.add(
dxf.insert(chip.ID,
insert=self.chipSpace(self.chipPts[index]),
layer=self.lyr(chip.layer)))
# set up the basic drawing
drawing = dxf.drawing('basic.dxf')
# create a block
board1 = dxf.block(name="board")
drawing.blocks.add(board1)
# create 3dfaces for cube
face1 = dxf.face3d([(0,0,0),(100,0,0),(100,100,0),(0,100,0)])
face2 = dxf.face3d([(0,0,0),(100,0,0),(100,0,100),(0,0,100)])
face3 = dxf.face3d([(0,0,0),(0,0,100),(0,100,100),(0,100,0)])
face4 = dxf.face3d([(100,0,0),(100,0,100),(100,100,100),(100,100,0)])
face5 = dxf.face3d([(0,0,100),(100,0,100),(100,100,100),(0,100,100)])
face6 = dxf.face3d([(0,100,0),(100,100,0),(100,100,100),(0,100,100)])
# add 3dface to block
board1.add(face1)
board1.add(face2)
board1.add(face3)
board1.add(face4)
board1.add(face5)
board1.add(face6)
# insert the block-create ref, then add to drawing
blockref = dxf.insert(blockname='board', insert=(0,0,0))
drawing.add(blockref)
drawing.save()
rotation = 30,
height=0.25,
text='test',
prompt='test eingeben:', # only important for interactive CAD systems
tag='TEST'
)
# add attdef to the block definition
block.add(attdef)
# add the block to the BLOCKS section
drawing.blocks.add(block)
# insert the block references
for x in range(1, 10):
block_ref = dxf.insert(
blockname='Rechteck',
insert=(x*2,10),
rotation=x*6,
xscale=x,
yscale=x)
# create an ATTRIB-entity from an ATTDEF-entity
attrib = attdef.new_attrib(
height=0.18,
text='attrib:%d' % x,
)
# add ATTRIB-entity to the block refernce
# relative insert, respects the block rotation
block_ref.add(attrib, relative=True)
# add block reference to drawing
drawing.add(block_ref)
insert=(.2, .2),
rotation=30,
height=0.25,
text='test',
prompt='test eingeben:', # only important for interactive CAD systems
tag='TEST')
# add attdef to the block definition
block.add(attdef)
# add the block to the BLOCKS section
drawing.blocks.add(block)
# insert the block references
for x in range(1, 10):
block_ref = dxf.insert(blockname='Rechteck',
insert=(x * 2, 10),
rotation=x * 6,
xscale=x,
yscale=x)
# create an ATTRIB-entity from an ATTDEF-entity
attrib = attdef.new_attrib(
height=0.18,
text='attrib:%d' % x,
)
# add ATTRIB-entity to the block refernce
# relative insert, respects the block rotation
block_ref.add(attrib, relative=True)
# add block reference to drawing
drawing.add(block_ref)
def main(args):
fname_stl = args.input
fname_dxf = args.output
slices_list = args.slices
k_e = args.slices_end_factors
proj_offsets = args.proj_offsets
plot_sections = args.plot_sections
# fname_stl, fname_dxf, slices_list, k_e, proj_offsets, plot_sections = args_t
sx = args.x_slices
sy = args.y_slices
sz = args.z_slices
print(sx, sy, sz)
if not len(fname_dxf):
fname_dxf = fname_stl.split('.')[0] + '.dxf'
print(fname_stl)
mesh_stl = mesh.Mesh.from_file(fname_stl)
dim_max = np.round(mesh_stl.max_, 3)
dim_min = np.round(mesh_stl.min_, 3)
sections_list = [
([1, 0,
0], dim_min[0] + k_e[0], dim_max[0] - k_e[0], slices_list[0], sx),
([0, 1,
0], dim_min[1] + k_e[1], dim_max[1] - k_e[1], slices_list[1], sy),
([0, 0,
1], dim_min[2] + k_e[2], dim_max[2] - k_e[2], slices_list[2], sz)
]
section_plane_list = []
for i, (norm, n_min, n_max, n_sect, s) in enumerate(sections_list):
print('slicing plane: ', i)
# n_sect=10
cp_n0_arr = np.tile(norm, (n_sect, 1))
if n_sect == 1:
cp_D0_arr = np.tile(norm, (n_sect, 1)) * np.array(
[0.5 * (n_min + n_max)])
else:
#k_e jest offsetem, ktory zapobiega rzutowaniu sciany na plaszczyzne.
#rzutowanie triangulowanej plaszczyzny skutkuje 'poszatkowaniem' rzutu i
#dodatkowej, manualnej obrobki dxfa
cp_D0_arr = np.tile(norm, (n_sect, 1)) * np.linspace(
n_min, n_max, n_sect)[:, np.newaxis]
if len(s):
s_cp_n0_arr = np.tile(norm, (len(s), 1))
s_cp_D0_arr = np.tile(norm,
(len(s), 1)) * np.array(s)[:, np.newaxis]
cp_D0_arr = np.vstack([cp_D0_arr, s_cp_D0_arr])
cp_D0_arr = np.unique(cp_D0_arr, axis=0)
cp_n0_arr = np.tile(norm, (cp_D0_arr.shape[0], 1))
# print(np.vstack([cp_n0_arr, s_cp_n0_arr]))
section_list = []
#
for i, (n0, D0) in enumerate(zip(cp_n0_arr, cp_D0_arr)):
intersect_list = []
# print(i)
for tri_list in mesh_stl.vectors:
tri = np.round(np.vstack(tri_list).astype(float), 6)
intersect = fc.tri_plane_intersect(tri, D0, n0)
if len(intersect) == 2:
intersect_list.append(np.vstack(intersect))
section_list.append(intersect_list)
section_plane_list.append(section_list)
drawing = dxf.drawing(fname_dxf)
drawing.add_layer('~slices_x')
drawing.add_layer('~slices_y')
drawing.add_layer('~slices_z')
for i, section_list in enumerate(section_plane_list):
for j, section in enumerate(section_list):
blockname_x = '_'.join(('slices_x', str(j)))
blockname_y = '_'.join(('slices_y', str(j)))
blockname_z = '_'.join(('slices_z', str(j)))
block_x = dxf.block(name=blockname_x)
block_y = dxf.block(name=blockname_y)
block_z = dxf.block(name=blockname_z)
drawing.add(block_x)
drawing.add(block_y)
drawing.add(block_z)
p_arr = np.array(section)
for row in p_arr:
if row.shape[0] == 2:
x0 = row[0, 0]
y0 = row[0, 1]
z0 = row[0, 2]
x1 = row[1, 0]
y1 = row[1, 1]
z1 = row[1, 2]
if i == 0:
if proj_offsets:
block_x.add(
dxf.line((z0 + x0, y0), (z1 + x1, y1),
thickness=0,
color=j))
else:
block_x.add(
dxf.line((y0, z0), (y1, z1),
thickness=0,
color=j))
block_x_ref = dxf.insert(blockname_x,
insert=(0, 0),
layer='~slices_x')
drawing.add(block_x_ref)
elif i == 1:
if proj_offsets:
block_y.add(
dxf.line((x0, z0 + y0), (x1, z1 + y0),
thickness=0,
color=j))
else:
block_y.add(
dxf.line((x0, z0), (x1, z1),
thickness=0,
color=j))
block_y_ref = dxf.insert(blockname_y,
insert=(0, 0),
layer='~slices_y')
drawing.add(block_y_ref)
elif i == 2:
if proj_offsets:
block_z.add(
dxf.line((x0, y0), (x1, y1),
thickness=0,
color=j))
else:
block_z.add(
dxf.line((x0, y0), (x1, y1),
thickness=0,
color=j))
block_z_ref = dxf.insert(blockname_z,
insert=(0, 0),
layer='~slices_z')
drawing.add(block_z_ref)
drawing.save()
if plot_sections:
fig = plt.figure()
ax = fig.gca(projection='3d')
for section_list in section_plane_list:
for i, section in enumerate(section_list):
p_arr = np.array(section)
for row in p_arr:
if row.shape[0] == 2:
# print(row)
x = row[:, 0]
y = row[:, 1]
z = row[:, 2]
ax.plot(x, y, z, 's-')
plt.show()
print('Thank you')
