def __init__(self,
wafer,
chipID,
layer,
structures=None,
defaults=None,
FRAME_NAME='FRAME'):
self.wafer = wafer
self.width = wafer.chipX - wafer.sawWidth
self.height = wafer.chipY - wafer.sawWidth
self.chipID = chipID #string (usually)
self.ID = 'CHIP_' + str(chipID)
self.solid = wafer.solid
self.frame = wafer.frame
self.layer = layer
if defaults is None:
self.defaults = {}
else:
self.defaults = defaults.copy()
#setup centering
self.center = (self.width / 2, self.height / 2)
#initialize the block
self.chipBlock = dxf.block(self.ID)
#setup structures
if structures is not None:
self.structures = structures
#add a debug frame for actual chip area
if wafer.frame:
self.add(
dxf.rectangle((0, 0),
self.width,
self.height,
layer=wafer.lyr(FRAME_NAME)))
def raith_alignment_marker(layer, w_r, pw_r, cc_x,
cc_y): #program does nothing as written
#questions: does the layer name have to be a string?
#In this case, the alignment marker elionix block will always be called the elionix block
cc = [cc_x, cc_y]
block = dxf.block("alignmentmarker_raith",
layer=layer) # creating the block
block.add(
dxf.rectangle((cc[0] - pw_r / 2, cc[1] - w_r / 2, 0),
pw_r,
w_r,
rotation=0,
layer=layer)) # long vertical
block.add(
dxf.rectangle((cc[0] - w_r / 2, cc[1] - pw_r / 2, 0),
(w_r - 2 - pw_r) / 2,
pw_r,
rotation=0,
layer=layer)) # short horizonal left
block.add(
dxf.rectangle((cc[0] + pw_r / 2, cc[1] - pw_r / 2, 0),
(w_r - 2 - pw_r) / 2,
pw_r,
rotation=0,
layer=layer)) # short horiztonal right
# add block-definition to drawing
#drawing.blocks.add(block_name)
print("I DID IT RAITH")
return block
def writeDXF(self):
fname = self.ui.lineEditOutputDXF.text()
file = open(fname, 'w')
rad = 0.25
scale = 1.0
col = 7
dec = self.ui.spinBoxDecimal.value()
dwg = dxf.drawing(fname)
# create block
scalarsymbol = dxf.block(name='symbol')
scalarsymbol.add( dxf.circle(radius=rad, color=0) )
# define some attributes
scalarsymbol.add( dxf.attdef(insert=(1.25, -1.25), tag='VAL1', height=1.25, color=0) )
# add block definition to the drawing
dwg.blocks.add(scalarsymbol)
for nID in self.points:
x = self.points[nID][0]
y = self.points[nID][1]
val1 = self.points[nID][2]
values = {'VAL1': "%.{0}f".format(dec) % val1}
dwg.add(dxf.insert2(blockdef=scalarsymbol, insert=(x, y),
attribs=values,
xscale=scale,
yscale=scale,
layer='0',
color = col))
dwg.save()
def double_dot_etch_block(layer, starting_gap, window_length, etch_window_1,
island_1, etch_window_2, island_2, etch_window_3,
blockname):
block = dxf.block(blockname, layer=layer) # creating the block
x_etch_position = starting_gap
block.add(
dxf.rectangle((x_etch_position, -window_length / 2),
etch_window_1,
window_length,
rotation=0,
layer=layer))
x_etch_position = starting_gap + etch_window_1 + island_1
block.add(
dxf.rectangle((x_etch_position, -window_length / 2),
etch_window_2,
window_length,
rotation=0,
layer=layer))
x_etch_position = starting_gap + etch_window_1 + island_1 + etch_window_2 + island_2
block.add(
dxf.rectangle((x_etch_position, -window_length / 2),
etch_window_3,
window_length,
rotation=0,
layer=layer)) # short horiztonal right
# add block-definition to drawing
#drawing.blocks.add(block_name)
print("I DID IT ETCH BLOCK")
return block
def plungers_side_mirror(
layer, plunger_to_nw, plunger_tip_width, plunger_tip_height,
plunger_taper_width,
blockname): #plungers on just one side of the nanowire
block = dxf.block(blockname, layer=layer)
taper = dxf.polyline(layer=layer)
taper.add_vertices([
(-plunger_tip_width / 2, -plunger_to_nw),
(plunger_tip_width / 2, -plunger_to_nw),
(plunger_taper_width / 2, -plunger_tip_height - plunger_to_nw),
(-plunger_taper_width / 2, -plunger_tip_height - plunger_to_nw)
])
taper.close(True)
block.add(taper)
taper_top = dxf.polyline(layer=layer)
taper_top.add_vertices([
(-plunger_tip_width / 2, plunger_to_nw),
(plunger_tip_width / 2, plunger_to_nw),
(plunger_taper_width / 2, plunger_tip_height + plunger_to_nw),
(-plunger_taper_width / 2, plunger_tip_height + plunger_to_nw)
])
taper_top.close(True)
block.add(taper_top)
return block
def tgates_side_mirror(layer, tgate_to_nw, tgate_tip_width, tgate_tip_height,
tgate_taper_width,
blockname): #plungers on just one side of the nanowire
block = dxf.block(blockname, layer=layer)
block.add(
dxf.rectangle((-tgate_tip_width / 2, -tgate_to_nw - tgate_taper_width),
tgate_tip_width,
tgate_taper_width,
rotation=0,
layer=layer))
block.add(
dxf.rectangle((-tgate_taper_width / 2,
-tgate_to_nw - tgate_taper_width - tgate_tip_height),
tgate_taper_width,
tgate_tip_height,
rotation=0,
layer=layer))
# block.add(dxf.rectangle((-tgate_tip_width/2,+tgate_to_nw),
# tgate_tip_width, tgate_taper_width, rotation = 0, layer = layer))
# block.add(dxf.rectangle((-tgate_taper_width/2, +tgate_to_nw+tgate_taper_width),
# tgate_taper_width, tgate_tip_height, rotation = 0, layer = layer))
return block # creating the block
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 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 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 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 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 vistec_alignment_marker(layer, h_v, w_v, cc_x,
cc_y): #program does nothing as written
cc = [cc_x, cc_y]
block = dxf.block("alignmentmarker_vistec",
layer=layer) # creating the block
block.add(
dxf.rectangle((cc[0] - w_v / 2, cc[1] - h_v / 2, 0),
w_v,
h_v,
rotation=0,
layer=layer)) # long vertical
print("I DID IT VISTEC")
return block
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 initial_test_etch_block(layer, window_spacing, start_window_width,
no_windows, window_length, window_size):
block = dxf.block("test_etch_block", layer=layer)
current_coordinate = window_spacing
window_size = start_window_width
for i in range(no_windows):
block.add(
dxf.rectangle((current_coordinate, -window_length / 2),
window_size,
window_length,
rotation=0))
current_coordinate += window_size + window_spacing
window_size += window_increment
return block
def test_insert2(self):
block = dxf.block('B1')
att1 = dxf.attdef('TAG1', (1.0, 0.0), height=0.35)
att2 = dxf.attdef('TAG2', (1.0, 0.5), height=0.35)
block.add(att1)
block.add(att2)
attribs = {'TAG1': 'TextForTAG1', 'TAG2': 'TextForTAG2'}
blockref = dxf.insert2(block, insert=(0, 0), attribs=attribs)
result = dxfstr(blockref)
self.assertTrue('TAG1' in result)
self.assertTrue('TAG2' in result)
self.assertTrue('TextForTAG1' in result)
self.assertTrue('TextForTAG2' in result)
def test_insert2(self):
block = dxf.block('B1')
att1 = dxf.attdef('TAG1', (1.0, 0.0), height=0.35)
att2 = dxf.attdef('TAG2', (1.0, 0.5), height=0.35)
block.add(att1)
block.add(att2)
attribs = {'TAG1': 'TextForTAG1', 'TAG2': 'TextForTAG2'}
blockref = dxf.insert2(block, insert=(0, 0), attribs=attribs)
result = dxfstr(blockref)
self.assertTrue('TAG1' in result)
self.assertTrue('TAG2' in result)
self.assertTrue('TextForTAG1' in result)
self.assertTrue('TextForTAG2' in result)
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 get_mat_symbol():
p1 = 0.5
p2 = 0.25
points = [(p1, p2), (p2, p1), (-p2, p1), (-p1, p2), (-p1, -p2),
(-p2, -p1), (p2, -p1), (p1, -p2)]
polygon = dxf.polyline(points, color=2)
polygon.close()
attdef = dxf.attdef(text='0', tag='num', height=0.7, color=1,
halign=dxfwrite.CENTER, valign=dxfwrite.MIDDLE
)
symbolblock = dxf.block('matsymbol')
symbolblock.add(polygon)
symbolblock.add(attdef)
dwg.blocks.add(symbolblock)
return symbolblock
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 elionix_alignment_marker(layer, w_e, pw_e, ph_e, ts_e, cc_x,
cc_y): #program does nothing as written
#questions: does the layer name have to be a string?
#In this case, the alignment marker elionix block will always be called the elionix block
cc = [cc_x, cc_y]
block = dxf.block("alignmentmarker_elionix",
layer=layer) # creating the block
block.add(
dxf.rectangle((cc[0] - pw_e / 2, cc[1] - w_e / 2, 0),
pw_e,
ph_e,
rotation=0)) #bottom square of alignment marker
block.add(
dxf.rectangle((cc[0] - w_e / 2, cc[1] - pw_e / 2, 0),
ph_e,
pw_e,
rotation=0)) # left square
block.add(
dxf.rectangle((cc[0] - pw_e / 2, cc[1] + w_e / 2 - ph_e, 0),
pw_e,
ph_e,
rotation=0)) # top square
block.add(
dxf.rectangle((cc[0] + w_e / 2 - ph_e, cc[1] - pw_e / 2, 0),
ph_e,
pw_e,
rotation=0)) # right square
block.add(
dxf.rectangle((cc[0] - ts_e / 2, cc[1] - w_e / 2 + ph_e, 0),
ts_e,
w_e - 2 * ph_e,
rotation=0)) # long vertical
block.add(
dxf.rectangle((cc[0] - ts_e / 2 -
(w_e - 2 * ph_e - ts_e) / 2, cc[1] - ts_e / 2, 0),
(w_e - 2 * ph_e - ts_e) / 2,
ts_e,
rotation=0)) # short horizonal left
block.add(
dxf.rectangle((cc[0] + ts_e / 2, cc[1] - ts_e / 2, 0),
(w_e - 2 * ph_e - ts_e) / 2,
ts_e,
rotation=0)) # short horiztonal right
# add block-definition to drawing
#drawing.blocks.add(block_name)
print("I DID IT ELIONIX")
return block
def get_mat_symbol():
p1 = 0.5
p2 = 0.25
points = [(p1, p2), (p2, p1), (-p2, p1), (-p1, p2), (-p1, -p2), (-p2, -p1),
(p2, -p1), (p1, -p2)]
polygon = dxf.polyline(points, color=2)
polygon.close()
attdef = dxf.attdef(text='0',
tag='num',
height=0.7,
color=1,
halign=dxfwrite.CENTER,
valign=dxfwrite.MIDDLE)
symbolblock = dxf.block('matsymbol')
symbolblock.add(polygon)
symbolblock.add(attdef)
dwg.blocks.add(symbolblock)
return symbolblock
def writeVectorDXF(nodes, VMin, VMax, eps, scale, fname):
colMono = 7
arrow = [(1.0,0.0),(0.6,-0.1),(0.6,0.1),(1.0,0.0)]
arrowline = [(0.0,0.0),(0.6,0.0)]
dwg = dxf.drawing(fname)
# create block
vectorsymbol = dxf.block(name='vector')
vectorsymbol.add( dxf.polyline(arrow, color=0) )
vectorsymbol.add( dxf.polyline(arrowline, color=0) )
# add block definition to the drawing
dwg.blocks.add(vectorsymbol)
nOfVectors = 0
for nID in nodes:
x = nodes[nID][0]
y = nodes[nID][1]
u = nodes[nID][2]
v = nodes[nID][3]
velocity = (u**2.0 + v**2.0)**(1.0/2.0)
phi = math.atan2(v,u)*180.0/math.pi
# write block, if value is inside a given band
blockScale = scale * velocity
if velocity <= VMax and velocity >= VMin:
if velocity < eps and velocity > -eps:
continue
else:
dwg.add(dxf.insert2(blockdef=vectorsymbol, insert= (x, y),
xscale=blockScale,
yscale=blockScale,
layer='0',
color = colMono,
rotation = phi))
nOfVectors += 1
dwg.save()
return nOfVectors
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)
# add a TEXT-entity
drawing.add(dxf.text("Manfred"))
# add a TEXT-entity with more properties
drawing.add(dxf.text(
text="mozman",
style="ISOCPEUR",
height=0.7,
oblique=15,
color=5,
insert=(0,5),
rotation=30,
))
# create BLOCK-entity
block = dxf.block(name='Rechteck')
# add DXF-entities to the block
block.add(dxflist_example(0, 0, 1, 1))
# create an ATTDEF-entity, can be use to crate new ATTRIBS with following
# default values, see attdef.new_attrib() call below
attdef = dxf.attdef(
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
def writeScalarDXF(nodes, SMin, SMax, eps, scale, symbol, useMono, fname):
colMono = 7
colPos = 1
colNeg = 3
hLine = [(-0.75,0.0), (0.75, 0.0)]
vLine = [(0.0,-0.75), (0.0,0.75)]
rad = 0.375
dwg = dxf.drawing(fname)
# create block
scalarsymbol = dxf.block(name='symbol')
if symbol != 0 and symbol != 3:
scalarsymbol.add( dxf.polyline(hLine, color=0) )
scalarsymbol.add( dxf.polyline(vLine, color=0) )
if symbol != 1 and symbol != 3:
scalarsymbol.add( dxf.circle(radius=rad, color=0) )
# define some attributes
scalarsymbol.add( dxf.attdef(insert=(0.5, 0.5), tag='VAL1', height=1.0, color=0) )
scalarsymbol.add( dxf.attdef(insert=(0.5, -1.5), tag='VAL2', height=1.0, color=0) )
# add block definition to the drawing
dwg.blocks.add(scalarsymbol)
nOfScalars = 0
for nID in nodes:
x = nodes[nID][0]
y = nodes[nID][1]
val1 = nodes[nID][2]
val2 = nodes[nID][3]
values = {}
if val2 is None:
values = {'VAL1': "%.2f" % val1, 'VAL2': ""}
else:
if val2 < eps and val2 > -eps:
values = {'VAL1': "%.2f" % val1, 'VAL2': ""}
else:
values = {'VAL1': "%.2f" % val1, 'VAL2': "%.2f" % val2}
# define color
col = 0
if useMono is True:
col = colMono
else:
if val1 >= 0:
col = colPos
else:
col = colNeg
if val1 >= SMin and val1 <= SMax:
if val1 < eps and val1 > -eps:
continue
else:
dwg.add(dxf.insert2(blockdef=scalarsymbol, insert=(x, y),
attribs=values,
xscale=scale,
yscale=scale,
layer='0',
color = col))
nOfScalars += 1
dwg.save()
return nOfScalars
#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),
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]+(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))
drawing.blocks.add(ame_orient)
orient_marker = dxf.insert(blockname='ame_orient', insert=(am_e_x[0],am_e_y[0]), columns = 1 , rows = 1,
colspacing = w_e+align_space_e, rowspacing = w_e+ align_space_e, layer = layer0, color =am_colour) #bot left
orient_marker1 = dxf.insert(blockname='ame_orient', insert=(am_e_x[1],am_e_y[1]), columns = 1 , rows = 1,
def get_random_point():
x = random.randint(-100, 100)
y = random.randint(-100, 100)
return (x, y)
sample_coords = [get_random_point() for x in range(50)]
flag_symbol = [(0, 0), (0, 5), (4, 3), (0, 3)]
filename = 'flags.dxf'
dwg = dxf.drawing(filename)
dwg.add_layer('FLAGS')
# first create a block
flag = dxf.block(name='flag')
# add dxf entities to the block (the flag)
# use basepoint = (x, y) define an other basepoint than (0, 0)
flag.add(dxf.polyline(flag_symbol))
flag.add(dxf.circle(radius=.4, color=2))
# define some attributes
flag.add(dxf.attdef(insert=(0.5, -0.5), tag='NAME', height=0.5, color=3))
flag.add(dxf.attdef(insert=(0.5, -1.0), tag='XPOS', height=0.25, color=4))
flag.add(dxf.attdef(insert=(0.5, -1.5), tag='YPOS', height=0.25, color=4))
# add block definition to the drawing
dwg.blocks.add(flag)
number = 1
for point in sample_coords:
# now insert flag symbols at coordinate 'point'
# insert2 needs the block definition object as parameter 'blockdef'
def render(self):
data = self.data
point_layers = {}
# create the drawing and add layers to it
drawing = dxf.drawing()
drawing.add_layer(self.filter_layer_name('objects'))
drawing.add_layer(self.filter_layer_name('marker'))
drawing.add_layer(self.filter_layer_name('Mesh'))
# Add layers from the doncodes
for l in set([
self.doncodes["doncodes"][lx]["CAD LAYERS"]
for lx in self.doncodes["doncodes"]
]):
if l:
drawing.add_layer(self.filter_layer_name(l))
# might need custom layers for major/minor contours
have_contour_names = []
for x in ["major", "minor"]:
if self.settings["job"].get("contours") and self.settings["job"][
"contours"][x] and self.settings["job"]["contours"][x].get(
"layer"):
drawing.add_layer(
self.filter_layer_name(
"Contour - " +
str(self.settings["job"]["contours"][x].get("layer"))))
have_contour_names.append(x)
if len(have_contour_names) < 2:
# drawing.add_layer(self.filter_layer_name('Contour'))
drawing.add_layer(self.filter_layer_name('Contour Splines'))
drawing.add_layer(self.filter_layer_name('Contour Splines Flat'))
# add the separated codes/shots/rls
for x in ["Shots", "Rls", "Codes"]:
for y in ["", "_NC", "_NL"]:
drawing.add_layer(self.filter_layer_name(x + y))
#drawing.header['$ANGBASE'] = self.bm["marker_angle"]
#drawing.header['$UCSORG'] = (0, 0, 0)
#drawing.header['$UCSXDIR'] = (1, 0, 0)
#drawing.header['$UCSYDIR'] = (0, 1, 0)
# set 3D Point
#drawing.header['$EXTMIN'] = (0, 0, -10)
#drawing.header['$EXTMAX'] = (1000, 1000, 100)
# add the mesh
if self.settings["options"]["threedMesh"] == "1":
self.render_mesh(drawing)
#add stringlines to string_lines layer
for line in data["stringlines"]:
if len(data["stringlines"][line]) > 1:
# variable to store stringline colour, thickness etc. to be passed to polyline
stringline_detail = {}
first_point = data["stringlines"][line][0]
ms_layer = first_point["doncode"].get("MS Properties")
layer_codes = self.doncodes["ms_layers"].get(ms_layer)
# make sure we have stringline properties in our doncodes array (often blank)
if layer_codes:
# print data["stringlines"][line][0]["code"], ms_layer
# print first_point["code"], layer_codes
# if we have a special colour
if layer_codes.get("Col"):
stringline_detail["color"] = int(layer_codes["Col"])
# if we have a line weight set
if layer_codes.get("Line Weight") and int(
layer_codes.get("Line Weight")):
stringline_detail["thickness"] = int(
layer_codes.get("Line Weight"))
# if we have a line style TODO: map these to their actual line styles
if layer_codes.get("Line Style") and int(
layer_codes.get("Line Style")):
stringline_detail["linetype"] = int(
layer_codes.get("Line Style"))
polyline = dxf.polyline(layer=self.filter_layer_name(
first_point["doncode"].get("CAD LAYERS")),
**stringline_detail)
polyline.add_vertices([
self.convert_point(p["point"])
for p in data["stringlines"][line]
])
drawing.add(polyline)
# add the regular (original) contour line
if self.settings["options"]["origContour"] == "1":
self.render_contour(drawing, data["contour_lines"],
lambda p: self.convert_point(
p)) # Line was previously commented.
# add splines contour line
if self.settings["options"]["splinesContour"] == "1":
# splines version
self.render_contour(drawing, data["contour_splines"],
lambda p: self.convert_point(p), " Splines")
# flat spline version
self.render_contour(
drawing, data["contour_splines"],
lambda p: self.flatten_point(self.convert_point(p)),
" Splines Flat")
# loop through the points with 2d objects on them putting Xrefs on the ones that need it
#print data["objects_2d"]
for o in data["objects_2d"]:
# //bush.position.set(objects_2d[o][0],objects_2d[o][1]+0.3,objects_2d[o][2]).multiplyScalar(psu_renderer.SCALE);
# psu_renderer.generate_obj(bush.clone());
drawing.add_xref(self.settings["global"].get("export", {}).get(
"xref_path", "") + o["code"] + ".dwg",
insert=self.convert_point(o["point"]),
layer=self.filter_layer_name(
o["doncode"].get("CAD LAYERS")))
# find and add trees to plot and tree schedule
# create the table for tree information
tree_table = dxf.table(insert=self.convert_point(
[self.bounding_box[0][1], 0, self.bounding_box[2][0] - 20]),
nrows=len(data["trees"]) + 2,
ncols=4)
tree_table.set_col_width(1, 4)
tree_table.set_col_width(2, 3)
tree_table.set_col_width(3, 5)
# table cell style
ctext = tree_table.new_cell_style('ctext',
textcolor=7,
textheight=0.5,
halign=dxfwrite.CENTER,
valign=dxfwrite.MIDDLE)
# table border style
border = tree_table.new_border_style(color=6, priority=51)
ctext.set_border_style(border, right=False)
# table header
hcell = tree_table.text_cell(0, 0, "SCHEDULE OF TREES")
hcell.span = (1, 4)
tree_table.text_cell(1, 1, "DIAMETER", style='ctext')
tree_table.text_cell(1, 2, "HEIGHT", style='ctext')
tree_table.text_cell(1, 3, "TYPE", style='ctext')
for t in range(len(data["trees"])):
tree = data["trees"][t]
diameter = tree["tree_details"].get("diameter", None)
height = tree["tree_details"].get("height", None)
spread = tree["tree_details"].get("spread", None)
note = tree["tree_details"].get("note", None)
blockname = "tree_" + str(t + 1)
layer = self.filter_layer_name(
self.doncodes["doncodes"][tree["code"]].get("CAD LAYERS"))
if diameter or spread:
tree_block = dxf.block(name=blockname)
# trunk
if diameter:
tree_block.add(
dxf.circle(float(diameter) / 2.0, [0, 0], layer=layer))
# leaves
if spread:
tree_block.add(
dxf.circle(float(spread) / 2.0, [0, 0], layer=layer))
drawing.blocks.add(tree_block)
drawing.add(
dxf.insert2(blockdef=tree_block,
insert=self.convert_point(tree["position"]),
layer=layer))
# table
# table position is left of bounding box
tree_table.text_cell(t + 2, 0, "T" + str(t + 1), style='ctext')
tree_table.text_cell(t + 2,
1,
diameter and diameter or "",
style='ctext')
tree_table.text_cell(t + 2,
2, (height and height + "m" or ""),
style='ctext')
tree_table.text_cell(t + 2,
3,
note and note.upper() or "",
style='ctext')
drawing.add(tree_table)
if not self.bm.get("fake"):
drawing.add(
dxf.point(self.convert_point(self.bm["position"]),
layer=self.filter_layer_name(
self.doncodes["doncodes"][self.bm["code"]].get(
"CAD LAYERS"))))
drawing.add(
dxf.text("BM",
self.convert_point(self.bm["position"]),
height=0.2,
layer=self.filter_layer_name(
self.doncodes["doncodes"][self.bm["code"]].get(
"CAD LAYERS"))))
# loop through the points adding labels to the layer
seen = []
for p in data["p"]:
# uniquely identify this piece of text at this position to prevent duplicates
text_id = tuple(
[p["original_code"], p.get("day_id", "")] + p["position"])
# figure out if we are NL or
layer_postfix = ""
for l in ["NL", "NC"]:
if l in p["extensions"]["function"]:
layer_postfix = "_" + l
# if this isn't a duplicate and isn't a tree
if not text_id in seen or p["code"] == "TR":
blockname = 'point_' + str(p["point_id"]) + (
p.get("day_id") and "-" + p["day_id"] or "")
point_block = dxf.block(name=blockname)
if p.get("force_point_layer"):
layer_code = p["force_point_layer"]["code"]
else:
layer_code = p["code"]
layer = self.filter_layer_name(
self.doncodes["doncodes"][layer_code].get("CAD LAYERS"))
# create a block to unite the various elements of the point
# for trees we just want to draw their ref
if p["code"] == "TR":
point_block.add(
dxf.text(
"T" +
str([t["point_id"]
for t in data["trees"]].index(p["point_id"]) +
1), [0.2, 0.2],
height=0.2,
layer="Codes" + layer_postfix))
else:
# these codes don't have the original_code text printed on the plot
if not p["code"] in ["RC", "LC"]:
# everything else gets original code printed
point_block.add(
dxf.text(p["original_code"] + " (" +
str(p["line_number"]) + ")", (0, 0),
alignpoint=(0, -0.2),
height=0.05,
rotation=-90,
layer="Codes" + layer_postfix,
valign=MIDDLE))
if not "NL" in p["extensions"]["function"]:
point_block.add(
dxf.text("%.2f" % (p["position"][1]), (0, 0),
alignpoint=(0.12, -0.12),
height=0.3,
rotation=-45,
layer="Rls" + layer_postfix,
valign=MIDDLE))
point_block.add(
dxf.point([0, 0], layer="Shots" + layer_postfix))
drawing.blocks.add(point_block)
drawing.add(
dxf.insert2(blockdef=point_block,
insert=self.convert_point(p["position"]),
layer=layer))
# print p["doncode"].get("Draw Cross Hair on Point")
if self.doncodes["doncodes"][p["code"]].get(
'Draw Cross Hair on Point',
'n').lower() in ["1", "y", "yes", "true", "x"]:
drawing.add_xref(self.settings["global"].get(
"export", {}).get("xref_path", "") + "X.dwg",
insert=self.convert_point(p["position"]),
layer="Shots" + layer_postfix)
seen.append(text_id)
# save the drawing to the binary blob and then return the DXF code
# binary blob to pretend to be a file and store our saved DXF
blob = StringIO()
drawing.save_to_fileobj(blob)
return blob.getvalue()
def get_random_point():
x = random.randint(-100, 100)
y = random.randint(-100, 100)
return (x, y)
sample_coords = [get_random_point() for x in range(50)]
flag_symbol = [(0,0), (0, 5), (4, 3), (0, 3)]
filename = 'flags.dxf'
dwg = dxf.drawing(filename)
dwg.add_layer('FLAGS')
# first create a block
flag = dxf.block(name='flag')
# add dxf entities to the block (the flag)
# use basepoint = (x, y) define an other basepoint than (0, 0)
flag.add( dxf.polyline(flag_symbol) )
flag.add( dxf.circle(radius=.4, color=2) )
# define some attributes
flag.add( dxf.attdef(insert=(0.5, -0.5), tag='NAME', height=0.5, color=3) )
flag.add( dxf.attdef(insert=(0.5, -1.0), tag='XPOS', height=0.25, color=4) )
flag.add( dxf.attdef(insert=(0.5, -1.5), tag='YPOS', height=0.25, color=4) )
# add block definition to the drawing
dwg.blocks.add(flag)
number = 1
for point in sample_coords:
# now insert flag symbols at coordinate 'point'
# insert2 needs the block definition object as parameter 'blockdef'
face3 = dxf.face3d([(lx,ly,lz),(lx,ly,z+lz),(lx,y+ly,z+lz),(lx,y+ly,lz)])
face4 = dxf.face3d([(x+lx,ly,lz),(x+lx,ly,z+lz),(x+lx,y+ly,z+lz),(x+lx,y+ly,lz)])
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)
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()
def writeCSDXF(fname, nameCS, nodeIDsCS, nodesCS, valuesCS, decFlow, scale, prefix, suffix):
from dxfwrite.const import TOP, BOTTOM, LEFT, CENTER, RIGHT
dwg = dxf.drawing(fname)
# create block for symbol on left side of CS
arrowLeft = [(0.0,0.25), (1.0, 0.25), (0.5, 1.1160), (0.0,0.25)]
symbolLeft = dxf.block(name='symbolLeft')
symbolLeft.add( dxf.solid(arrowLeft, color=0) )
symbolLeft.add( dxf.attdef(insert=(0, -0.25), tag='CS', height=1.0, color=0, halign=LEFT, valign=TOP ))
# create block for symbol on right side of CS
arrowRight = [(0.0,0.25), (-1.0, 0.25), (-0.5, 1.1160), (0.0,0.25)]
symbolRight = dxf.block(name='symbolRight')
symbolRight.add( dxf.solid(arrowRight, color=0) )
symbolRight.add( dxf.attdef(insert=(0, -0.25), tag='CS', height=1.0, color=0, halign=RIGHT, valign=TOP ))
# create block for symbol on center of CS
symbolCenter = dxf.block(name='symbolCenter')
symbolCenter.add( dxf.attdef(insert=(0.0, 0.03), tag='MAX', height=0.75, color=0, halign=CENTER, valign=BOTTOM) )
symbolCenter.add( dxf.attdef(insert=(0.0, -0.25), tag='MIN', height=0.75, color=0, halign=CENTER, valign=TOP) )
# add block definitions to the drawing
dwg.blocks.add(symbolLeft)
dwg.blocks.add(symbolCenter)
dwg.blocks.add(symbolRight)
for csID in nodeIDsCS:
x1 = nodesCS[nodeIDsCS[csID][0]][0]
x2 = nodesCS[nodeIDsCS[csID][1]][0]
y1 = nodesCS[nodeIDsCS[csID][0]][1]
y2 = nodesCS[nodeIDsCS[csID][1]][1]
p1 = (x1, y1)
p2 = (x2, y2)
dx = x2 - x1
dy = y2 - y1
phi = math.atan2(dy,dx)*180.0/math.pi
pm = ((x1+x2)/2.0, (y1+y2)/2.0)
valMin = valuesCS[csID][0]
valMax = valuesCS[csID][1]
dwg.add(dxf.polyline((p1, p2)))
values = {'CS': "{0}".format(nameCS[csID])}
dwg.add(dxf.insert2(blockdef=symbolLeft, insert=p1,
attribs=values,
xscale=scale,
yscale=scale,
layer='0',
rotation = phi))
dwg.add(dxf.insert2(blockdef=symbolRight, insert=p2,
attribs=values,
xscale=scale,
yscale=scale,
layer='0',
rotation = phi))
valuesCenter = {'MIN': "{0}%.{1}f{2} (min)".format(prefix, decFlow, suffix) % valMin, 'MAX': "{0}%.{1}f{2} (max)".format(prefix, decFlow, suffix) % valMax}
dwg.add(dxf.insert2(blockdef=symbolCenter, insert=pm,
attribs=valuesCenter,
xscale=scale,
yscale=scale,
layer='0',
rotation = phi))
dwg.save()
#!/usr/bin/python
from dxfwrite import DXFEngine as dxf
# 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)
def defineHiVisMarker09(self, width, layer):
for i in range(10):
num = dxf.block('0' + str(i))
HiVisMarker09(num, 0, 0, i, width, self.bg(layer))
self.drawing.blocks.add(num)
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)))
drawing.add(dxf.text("Manfred"))
# add a TEXT-entity with more properties
drawing.add(
dxf.text(
text="mozman",
style="ISOCPEUR",
height=0.7,
oblique=15,
color=5,
insert=(0, 5),
rotation=30,
))
# create BLOCK-entity
block = dxf.block(name='Rechteck')
# add DXF-entities to the block
block.add(dxflist_example(0, 0, 1, 1))
# create an ATTDEF-entity, can be use to crate new ATTRIBS with following
# default values, see attdef.new_attrib() call below
attdef = dxf.attdef(
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)
(am_e_gridheight * am_elionix + am_r_gridheight * am_raith +
am_v_gridheight * am_vistec)):
print(
"The die length is not long enough to support the dimensions of your alignment markers"
)
quit()
if die_width < (2 * align_distance +
(am_e_gridwidth * am_elionix + am_r_gridwidth * am_raith +
am_v_gridwidth * am_vistec)):
print(
"The die width is not long enough to support the dimensions of your alignment markers"
)
quit()
#BLOCK for ELIONIX
ame = dxf.block("alignmentmarker_elionix", layer=layer0) # creating the block
ame.add(
dxf.rectangle((cc[0] - pw_e / 2, cc[1] - w_e / 2, 0),
pw_e,
ph_e,
color=am_colour,
rotation=0,
layer=layer0)) #bottom square of alignment marker
ame.add(
dxf.rectangle((cc[0] - w_e / 2, cc[1] - pw_e / 2, 0),
ph_e,
pw_e,
color=am_colour,
rotation=0,
layer=layer0)) # left square
ame.add(
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')
