def __init__(self,
wafer,
chipID,
w=40,
l=1500,
pad_extend=1000,
offset=(0, 0)):
m.BlankCenteredWR10.__init__(self, wafer, chipID, wafer.defaultLayer,
offset)
#put in a resistance bar
self.add(
dxf.rectangle((-pad_extend + offset[0], 0),
pad_extend + self.width / 2 - l / 2,
self.height,
bgcolor=wafer.bg(wafer.defaultLayer)))
self.add(
dxf.rectangle((self.width / 2 + l / 2 + offset[0], 0),
pad_extend + self.width / 2 - l / 2,
self.height,
bgcolor=wafer.bg(wafer.defaultLayer)))
self.add(
dxf.rectangle(self.centered((-l / 2, -w / 2)),
l,
w,
bgcolor=wafer.bg(wafer.defaultLayer)))
def getRectangleDxf(self, for_prime_center=True):
x = self.getPosition()[0] - self.getWidth()/2
y = self.getPosition()[1] - self.getHeight()/2
width = self.getWidth()
height = self.getHeight()
# if self.isCoupage() and (height > width) and height <= self.getGridWidth():
# # rotate when more optimal
# width = self.getHeight()
# height = self.getWidth()
if for_prime_center == True:
x = Helper.toMillimeters(x)
y = Helper.toMillimeters(y)
width = Helper.toMillimeters(width)
height = Helper.toMillimeters(height)
bgcolor = random.randint(1,255)
return dxf.rectangle((y,x), height, width,
bgcolor=bgcolor)
else:
bgcolor = random.randint(1,255)
return dxf.rectangle((x, y), width, height,
bgcolor=bgcolor)
def __init__(self,
wafer,
chipID,
w=40,
l=1500,
pad_extend=1000,
offset=(0, 0),
overhang=80):
m.BlankCenteredWR10.__init__(self, wafer, chipID, wafer.defaultLayer,
offset)
#put in holes to define a resistance bar
#self.add(dxf.rectangle((-pad_extend+offset[0],0),pad_extend+self.width/2-l/2,self.height,bgcolor=wafer.bg(wafer.defaultLayer)))
#self.add(dxf.rectangle((self.width/2 + l/2+offset[0],0),pad_extend+self.width/2-l/2,self.height,bgcolor=wafer.bg(wafer.defaultLayer)))
self.add(
dxf.rectangle(self.centered((0, -w / 2)),
l,
self.height / 2 - w / 2 + overhang,
halign=const.CENTER,
valign=const.BOTTOM,
bgcolor=wafer.bg(wafer.defaultLayer)))
self.add(
dxf.rectangle(self.centered((0, w / 2)),
l,
self.height / 2 - w / 2 + overhang,
halign=const.CENTER,
valign=const.TOP,
bgcolor=wafer.bg(wafer.defaultLayer)))
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 __init__(self, wafer, chipID, pad, notch, globalOffset=(0, 0)):
m.BlankCenteredWR10.__init__(self, wafer, chipID, wafer.defaultLayer,
globalOffset)
self.wr10x = 2540 + 2 * pad
self.wr10y = 1270 + 2 * pad
color = wafer.bg(wafer.defaultLayer)
#positive regions define metal
self.add(
dxf.rectangle((self.cx(-self.wr10x / 2), 0),
self.wr10x,
self.cy(-self.wr10y / 2),
bgcolor=color))
self.add(
dxf.rectangle((0, self.height),
self.width,
self.cy(self.wr10y / 2 - self.height),
bgcolor=color))
self.add(
dxf.rectangle((0, notch),
self.cx(-self.wr10x / 2),
self.cy(self.wr10y / 2 - notch),
bgcolor=color))
self.add(
dxf.rectangle((self.cx(self.wr10x / 2), 0),
-self.cx(self.wr10x / 2 - self.width),
self.cy(self.wr10y / 2),
bgcolor=color))
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 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 slates(drawing, startx, starty, number_of_slates):
x_increment = 0
y_increment = 0
for n in range(0, number_of_slates):
# top of slates
drawing.add(dxf.line( (startx, starty + (slate_length*n) ),
(startx+slate_width, starty + (slate_length*n) ),
layer='CUTSINNEREARLY', color=3)
)
# left hand side cable tie hole
drawing.add(dxf.rectangle((startx + 5, starty + 5 + (slate_length*n)) , 5, 5, layer='CUTSINNEREARLY', color=3))
# right hand side cable tie hole
drawing.add(dxf.rectangle((startx + slate_width- 10, starty + 5 + (slate_length*n)) , 5, 5, layer='CUTSINNEREARLY', color=3))
# Cog hole
drawing.add(dxf.rectangle((startx + 130, starty + 5 + (slate_length*n)) , 5, 5, layer='CUTSINNEREARLY', color=3))
y_increment = y_increment + slate_length
# bottom of slates
drawing.add(dxf.line( (startx, starty + (slate_length*number_of_slates) ),
(startx+slate_width, starty + (slate_length*number_of_slates) ),
layer='CUTSINNEREARLY', color=3)
)
# left and right sides of slates
drawing.add(dxf.line( (startx, starty ),
(startx, starty + (slate_length*number_of_slates) ),
layer='CUTSINNER', color=4)
)
drawing.add(dxf.line( (startx+slate_width, starty ),
(startx+slate_width, starty + (slate_length*number_of_slates) ),
layer='CUTSINNER', color=4)
)
return (x_increment, y_increment)
def MarkerCross(w,pos,size=(200,200),linewidth=80,bgcolor=None,layer=None,chipCentered=False,**kwargs):
if layer is None:
layer = w.defaultLayer
else:
layer = w.lyr(layer)
if bgcolor is None:
bgcolor = w.bg(layer)
if chipCentered:
try:
pos = w.centered(pos)
except:
print('does not have centered argument')
w.add(dxf.rectangle(pos,size[0],linewidth,valign=const.MIDDLE,halign=const.CENTER,bgcolor=bgcolor,layer=layer,**kwargStrip(kwargs)))
w.add(dxf.rectangle(vadd(pos,(0,linewidth/2)),linewidth,size[1]/2-linewidth/2,valign=const.TOP,halign=const.CENTER,bgcolor=bgcolor,layer=layer,**kwargStrip(kwargs)))
w.add(dxf.rectangle(vadd(pos,(0,-linewidth/2)),linewidth,size[1]/2-linewidth/2,valign=const.BOTTOM,halign=const.CENTER,bgcolor=bgcolor,layer=layer,**kwargStrip(kwargs)))
def color_square(x, y, color=None, bgcolor=None):
if color:
name = color_name(color)
if bgcolor:
name = color_name(bgcolor)
drawing.add(dxf.rectangle((x, y) , 2, 2, color=color, bgcolor=bgcolor))
drawing.add(dxf.text(name, (x, y-0.4), height=0.18))
def color_square(x, y, color=None, bgcolor=None):
if color:
name = color_name(color)
if bgcolor:
name = color_name(bgcolor)
drawing.add(dxf.rectangle((x, y), 2, 2, color=color, bgcolor=bgcolor))
drawing.add(dxf.text(name, (x, y - 0.4), height=0.18))
def HiVisMarker09(dwg,xpos,ypos,number,width,bg=None,**kwargs):
shapes = [[], [[0,0]], [[0,0],[1,1]], [[0,0],[1,1],[0,1]], [[0,0],[0,1],[2,0],[2,1]],
[[0,1],[1,0],[2,1]], [[0,0],[1,0],[2,0],[1,1]], [[0,0],[0,1],[1,0],[1,1],[2,1]], [[0,0],[0,1],[1,0],[1,1]],
[[0,0],[1,0],[1,1],[2,1]]]
number = number % len(shapes)
for v in shapes[number]:
dwg.add(dxf.rectangle((xpos+v[0]*width,ypos+v[1]*width),width,width,bgcolor=bg,**kwargs))
def Slot_straight(chip,
structure,
length,
s=None,
bgcolor=None,
**kwargs): #note: uses CPW conventions
def struct():
if isinstance(structure, m.Structure):
return structure
elif isinstance(structure, tuple):
return m.Structure(chip, structure)
else:
return chip.structure(structure)
if bgcolor is None:
bgcolor = chip.wafer.bg()
if s is None:
try:
s = struct().defaults['s']
except KeyError:
try:
s = struct().defaults['w']
except KeyError:
print('\x1b[33mw not defined in ', chip.chipID, '!\x1b[0m')
print('\x1b[33ms not defined in ', chip.chipID, '!\x1b[0m')
chip.add(dxf.rectangle(struct().start,
length,
s,
valign=const.MIDDLE,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargStrip(kwargs)),
structure=structure,
length=length)
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 __init__(self, wafer, chipID, layer, filling, ribs=0):
Chip.__init__(self, wafer, chipID, layer)
self.filling = filling
if ribs > 0:
for i in range(int(self.height / ribs)):
self.add(
dxf.rectangle(
(self.cx(-self.width * filling / 2), i * ribs),
self.width * filling,
ribs / 2,
bgcolor=wafer.bg(layer)))
else:
self.add(
dxf.rectangle((self.cx(-self.width * filling / 2), 0),
self.width * filling,
self.height,
bgcolor=wafer.bg(layer)))
def __init__(self, wafer, chipID, layer, offset=(0, 0)):
Chip.__init__(self, wafer, chipID, layer)
self.center = self.centered(offset)
if wafer.frame:
self.add(
dxf.rectangle(self.centered((-1270, -635)),
2540,
1270,
layer=wafer.lyr('FRAME')))
def draw_sizing_refs():
from dxfwrite import DXFEngine as dxf
from dxfwrite.const import LEFT, TOP
d.dwg.add(dxf.rectangle(
insert=(part_padding, -part_padding - 10.0),
width=10.0,
height=10.0,
layer="LABELS",
))
d.dwg.add(dxf.text(
"10mm ref.",
halign=LEFT,
valign=TOP,
alignpoint=((part_padding * 2.0) + 10.0, -part_padding),
height=5,
layer="LABELS",
))
inch = 25.4
d.dwg.add(dxf.rectangle(
insert=(part_padding, -part_padding - 40.4),
width=inch,
height=inch,
layer="LABELS",
))
d.dwg.add(dxf.text(
"1 inch ref. (%0.2fmm)" % inch,
halign=LEFT,
valign=TOP,
alignpoint=((part_padding * 2.0) + inch, -part_padding - 40.4 + inch),
height=5,
layer="LABELS",
))
d.dwg.add(dxf.text(
"(10mm ref. is authoritative)",
halign=LEFT,
valign=TOP,
alignpoint=((part_padding * 2.0) + inch, -part_padding - 40.4 + (inch / 2)),
height=5,
layer="LABELS",
))
def __init__(self, wafer, chipID, studSize, globalOffset=(0, 0)):
m.BlankCenteredWR10.__init__(self, wafer, chipID, wafer.defaultLayer,
globalOffset)
#assume a marker on lower left. add 3 studs on opposite corners to make the chip evenly balanced
self.add(
dxf.rectangle((0, self.height),
studSize,
-studSize,
bgcolor=wafer.bg(wafer.defaultLayer)))
self.add(
dxf.rectangle((self.width, 0),
-studSize,
studSize,
bgcolor=wafer.bg(wafer.defaultLayer)))
self.add(
dxf.rectangle((self.width, self.height),
-studSize,
-studSize,
bgcolor=wafer.bg(wafer.defaultLayer)))
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 CPS_Resonator(dwg, xy, w, s, L_res, L_rabbit, bg=None, w_rabbit=None):
if w_rabbit is None:
w_rabbit = w
#draw a cps resonator, dipole origin centered on (x,y) facing right
dwg.add(dxf.rectangle((xy[0], xy[1] + s / 2), L_res, w, bgcolor=bg))
dwg.add(dxf.rectangle((xy[0], xy[1] - s / 2), L_res, -w, bgcolor=bg))
dwg.add(
dxf.rectangle((xy[0] + L_res, xy[1] - s / 2 - w),
w,
2 * w + s,
bgcolor=bg))
if L_rabbit > 0:
dwg.add(
dxf.rectangle((xy[0], xy[1] + s / 2 + w),
w_rabbit,
L_rabbit + (w_rabbit - w),
bgcolor=bg))
dwg.add(
dxf.rectangle((xy[0], xy[1] - s / 2 - w),
w_rabbit,
-L_rabbit - (w_rabbit - w),
bgcolor=bg))
def MarkerRect(w,pos,width,height,bgcolor=None,layer=None,chipCentered=False,**kwargs):
if layer is None:
layer = w.defaultLayer
else:
layer = w.lyr(layer)
if bgcolor is None:
bgcolor = w.bg(layer)
if chipCentered:
try:
pos = w.centered(pos)
except:
print('does not have centered argument')
w.add(dxf.rectangle(pos,width,height,valign=const.MIDDLE,halign=const.CENTER,bgcolor=bgcolor,layer=layer,**kwargStrip(kwargs)))
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 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 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 drawmask(self,index): numberOfPoints = int(len(self.mask[index])/2) # Pair points as x,y. points = [] for i in range(numberOfPoints): x = self.mask[index][i*2] y = self.mask[index][i*2+1] points.append([x,y]) points.append(points[0]) # NEED TO ROTATE POINTS BY 90 CCW # Create dwg and add lines. fn = 'BeamPort'+str(index)+'.dxf' dwg = dxf.drawing(fn) dwg.add(dxf.polyline(points)) dwg.add(dxf.rectangle([-self.maskSize[0]/2,-self.maskSize[1]/2], self.maskSize[0],self.maskSize[1])) dwg.save()
def drawMilimeter(cm):
for mm in range(10):
x_pos = tick_offset + 10 * cm + mm
if mm == 0: #desenha o traço mais comprido na marcação de cada centímetro
y_pos = 20
file.add(
dxf.text(str(cm), [x_pos - 1, 20],
height=2,
rotation=90,
layer='SCAN'))
elif mm == 5: #desenha o traço médio na marcação de cada meio centímetro
y_pos = 25
else: #desenha o traço curto na marcação de cada milimetro
y_pos = 27.5
file.add(
dxf.rectangle([x_pos, y_pos],
tick_width,
ruler_width - y_pos,
layer='SCAN'))
if cm == ruler_length: break
def Hamburgermon(chip,
pos,
rotation=0,
qwidth=1120,
qheight=795,
qr_out=200,
minQbunToGnd=100,
qbunwidth=960,
qbunthick=0,
qbunr=60,
qbunseparation=69.3751,
qccap_padw=40,
qccap_padl=170,
qccap_padr_out=10,
qccap_padr_ins=4.5,
qccap_gap=30,
qccapl=210,
qccapw=0,
qccapr_ins=30,
qccapr_out=15,
qccap_steml=70,
qccap_stemw=None,
XLAYER=None,
bgcolor=None,
**kwargs):
'''
Generates a hamburger shaped qubit. Needs XOR layers to define base metal layer.
Junction and contact tab parameters are monkey patched to Junction function through kwargs.
'''
thisStructure = None
if isinstance(pos, tuple):
thisStructure = m.Structure(chip, start=pos, direction=rotation)
def struct():
if isinstance(pos, m.Structure):
return pos
elif isinstance(pos, tuple):
return thisStructure
else:
return chip.structure(pos)
if bgcolor is None: #color for junction, not undercut
bgcolor = chip.wafer.bg()
#get layers from wafer
if XLAYER is None:
try:
XLAYER = chip.wafer.XLAYER
except AttributeError:
chip.wafer.setupXORlayer()
XLAYER = chip.wafer.XLAYER
if qccap_stemw is None:
try:
qccap_stemw = struct().defaults['w']
except KeyError:
print('\x1b[33mw not defined in ', chip.chipID, '!\x1b[0m')
qccap_stemw = 6
#increase thicknesses if radii are too large
qccapw = max(qccapw, 2 * qccapr_out)
qbunthick = max(qbunthick, 2 * qbunr)
qccap_padw = max(qccap_padw, 2 * qccap_padr_out)
qccap_padl = max(qccap_padl, 2 * qccap_padr_out)
#increase qubit width and height if buns are too close to ground
qwidth = max(qwidth, qbunwidth + 2 * minQbunToGnd)
qheight = max(
qheight,
max(qccap_steml + qccap_padl, qccap_gap + qccapl) +
2 * max(2 * qbunr, qbunthick) + qbunseparation + minQbunToGnd)
#cache junction position and figure out if we're using structures or not
jxpos = qccap_steml + qccap_padl + qccap_gap + qbunthick + qbunseparation / 2
if thisStructure is not None:
#not using structures
struct().shiftPos(-jxpos)
centerPos = struct().getPos((jxpos, 0))
#hole in basemetal (negative)
chip.add(
RoundRect(struct().start,
qheight,
qwidth,
qr_out,
valign=const.MIDDLE,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs))
#xor defined qubit (positive)
if qccap_padr_ins > 0 and qccap_stemw + 2 * qccap_padr_ins < qccap_padw - 2 * qccap_padr_out:
chip.add(
InsideCurve(struct().getPos((qccap_steml, qccap_stemw / 2)),
qccap_padr_ins,
vflip=True,
rotation=struct().direction,
layer=XLAYER,
bgcolor=chip.bg(XLAYER),
**kwargs))
chip.add(
InsideCurve(struct().getPos((qccap_steml, -qccap_stemw / 2)),
qccap_padr_ins,
rotation=struct().direction,
layer=XLAYER,
bgcolor=chip.bg(XLAYER),
**kwargs))
chip.add(
dxf.rectangle(struct().start,
qccap_steml,
qccap_stemw,
valign=const.MIDDLE,
rotation=struct().direction,
layer=XLAYER,
bgcolor=chip.bg(XLAYER),
**kwargStrip(kwargs)))
chip.add(
RoundRect(struct().getPos((qccap_steml, 0)),
qccap_padl,
qccap_padw,
qccap_padr_out,
valign=const.MIDDLE,
rotation=struct().direction,
layer=XLAYER,
bgcolor=chip.bg(XLAYER),
**kwargs))
if qccapr_ins > 0:
chip.add(
InsideCurve(struct().getPos(
(jxpos - qbunseparation / 2 - qbunthick,
qccap_padw / 2 + qccap_gap)),
qccapr_ins,
rotation=struct().direction,
layer=XLAYER,
bgcolor=chip.bg(XLAYER),
**kwargs))
chip.add(
InsideCurve(struct().getPos(
(jxpos - qbunseparation / 2 - qbunthick,
qccap_padw / 2 + qccap_gap + qccapw)),
qccapr_ins,
vflip=True,
rotation=struct().direction,
layer=XLAYER,
bgcolor=chip.bg(XLAYER),
**kwargs))
chip.add(
InsideCurve(struct().getPos(
(jxpos - qbunseparation / 2 - qbunthick,
-qccap_padw / 2 - qccap_gap)),
qccapr_ins,
vflip=True,
rotation=struct().direction,
layer=XLAYER,
bgcolor=chip.bg(XLAYER),
**kwargs))
chip.add(
InsideCurve(struct().getPos(
(jxpos - qbunseparation / 2 - qbunthick,
-qccap_padw / 2 - qccap_gap - qccapw)),
qccapr_ins,
rotation=struct().direction,
layer=XLAYER,
bgcolor=chip.bg(XLAYER),
**kwargs))
chip.add(
RoundRect(struct().getPos((jxpos - qbunseparation / 2 - qbunthick,
qccap_padw / 2 + qccap_gap)),
qccapl,
qccapw,
qccapr_out,
roundCorners=[1, 0, 0, 1],
halign=const.RIGHT,
rotation=struct().direction,
layer=XLAYER,
bgcolor=chip.bg(XLAYER),
**kwargs))
chip.add(
RoundRect(struct().getPos((jxpos - qbunseparation / 2 - qbunthick,
-qccap_padw / 2 - qccap_gap)),
qccapl,
qccapw,
qccapr_out,
roundCorners=[1, 0, 0, 1],
halign=const.RIGHT,
vflip=True,
rotation=struct().direction,
layer=XLAYER,
bgcolor=chip.bg(XLAYER),
**kwargs))
JProbePads(chip,
centerPos,
rotation=struct().direction,
padwidth=qbunthick,
padheight=qbunwidth,
padradius=qbunr,
separation=qbunseparation,
layer=XLAYER,
bgcolor=chip.bg(XLAYER),
**kwargs)
ManhattanJunction(chip,
centerPos,
rotation=struct().direction,
separation=qbunseparation,
**kwargs)
return centerPos, struct().direction
def TransmonPad(chip,
pos,
padwidth=250,
padheight=None,
padradius=25,
tab=False,
tabShoulder=False,
tabShoulderWidth=30,
tabShoulderLength=80,
tabShoulderRadius=None,
flipped=False,
rotation=0,
bgcolor=None,
**kwargs):
'''
Creates a rectangular pad with rounded corners, and a JContactTab on one end (defaults to right)
No overlap : XOR mode compatible
Optionally set tabShoulder to True to extend a thinner lead from the main contact pad.
'''
def struct():
if isinstance(pos, m.Structure):
return pos
elif isinstance(pos, tuple):
return m.Structure(chip, start=pos, direction=rotation)
else:
return chip.structure(pos)
if tabShoulderRadius is None:
try:
tabShoulderRadius = struct().defaults['r_out']
except KeyError:
#print('\x1b[33mr_out not defined in ',chip.chipID,'!\x1b[0m')
tabShoulderRadius = 0
if bgcolor is None:
bgcolor = chip.wafer.bg()
if padheight is None:
padheight = padwidth
if padradius is None:
try:
padradius = struct().defaults['r_out']
except KeyError:
#print('\x1b[33mr_out not defined in ',chip.chipID,'!\x1b[0m')
padradius = 0
tablength, tabhwidth = JcalcTabDims(chip, pos, **kwargs)
if tab:
#positive tab
if not flipped:
chip.add(RoundRect(struct().start,
padwidth,
padheight,
padradius,
valign=const.MIDDLE,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs),
structure=struct(),
length=padwidth)
if tabShoulder:
chip.add(RoundRect(struct().start,
tabShoulderLength,
tabShoulderWidth,
tabShoulderRadius,
roundCorners=[0, 1, 1, 0],
valign=const.MIDDLE,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs),
structure=struct(),
length=tabShoulderLength)
JContact_tab(chip, struct(), hflip=flipped, **kwargs)
if flipped:
if tabShoulder:
chip.add(RoundRect(struct().start,
tabShoulderLength,
tabShoulderWidth,
tabShoulderRadius,
roundCorners=[1, 0, 0, 1],
valign=const.MIDDLE,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs),
structure=struct(),
length=tabShoulderLength)
chip.add(
RoundRect(struct().start,
padwidth,
padheight,
padradius,
valign=const.MIDDLE,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs))
else:
#slot
if not flipped:
if tabShoulder:
chip.add(RoundRect(struct().start,
padwidth,
padheight,
padradius,
valign=const.MIDDLE,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs),
structure=struct(),
length=padwidth)
chip.add(
RoundRect(struct().getPos((0, tabhwidth)),
tabShoulderLength,
tabShoulderWidth / 2 - tabhwidth,
min(tabShoulderRadius,
(tabShoulderWidth / 2 - tabhwidth) / 2),
roundCorners=[0, 0, 1, 0],
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs))
chip.add(
RoundRect(struct().getPos((0, -tabhwidth)),
tabShoulderLength,
tabShoulderWidth / 2 - tabhwidth,
min(tabShoulderRadius,
(tabShoulderWidth / 2 - tabhwidth) / 2),
roundCorners=[0, 1, 0, 0],
valign=const.TOP,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs))
chip.add(dxf.rectangle(struct().start,
tabShoulderLength - tablength,
2 * tabhwidth,
valign=const.MIDDLE,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargStrip(kwargs)),
structure=struct(),
length=tabShoulderLength - tablength)
else:
chip.add(
RoundRect(struct().getPos((0, tabhwidth)),
padwidth,
padheight / 2 - tabhwidth,
padradius,
roundCorners=[0, 0, 1, 1],
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs))
chip.add(
RoundRect(struct().getPos((0, -tabhwidth)),
padwidth,
padheight / 2 - tabhwidth,
padradius,
roundCorners=[1, 1, 0, 0],
valign=const.TOP,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs))
chip.add(dxf.rectangle(struct().start,
padwidth - tablength,
2 * tabhwidth,
valign=const.MIDDLE,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargStrip(kwargs)),
structure=struct(),
length=padwidth - tablength)
JContact_slot(chip, struct(), hflip=not flipped, **kwargs)
if flipped:
if tabShoulder:
chip.add(
RoundRect(struct().getPos((-tablength, tabhwidth)),
tabShoulderLength,
tabShoulderWidth / 2 - tabhwidth,
min(tabShoulderRadius,
(tabShoulderWidth / 2 - tabhwidth) / 2),
roundCorners=[0, 0, 0, 1],
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs))
chip.add(
RoundRect(struct().getPos((-tablength, -tabhwidth)),
tabShoulderLength,
tabShoulderWidth / 2 - tabhwidth,
min(tabShoulderRadius,
(tabShoulderWidth / 2 - tabhwidth) / 2),
roundCorners=[1, 0, 0, 0],
valign=const.TOP,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs))
chip.add(dxf.rectangle(struct().start,
tabShoulderLength - tablength,
2 * tabhwidth,
valign=const.MIDDLE,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargStrip(kwargs)),
structure=struct(),
length=tabShoulderLength - tablength)
chip.add(RoundRect(struct().start,
padwidth,
padheight,
padradius,
valign=const.MIDDLE,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs),
structure=struct(),
length=padwidth)
else:
chip.add(
RoundRect(struct().getPos((-tablength, tabhwidth)),
padwidth,
padheight / 2 - tabhwidth,
padradius,
roundCorners=[0, 0, 1, 1],
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs))
chip.add(
RoundRect(struct().getPos((-tablength, -tabhwidth)),
padwidth,
padheight / 2 - tabhwidth,
padradius,
roundCorners=[1, 1, 0, 0],
valign=const.TOP,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargs))
chip.add(
dxf.rectangle(struct().start,
padwidth - tablength,
2 * tabhwidth,
valign=const.MIDDLE,
rotation=struct().direction,
bgcolor=bgcolor,
**kwargStrip(kwargs)))
# 60-degree hex grid
hexperf = perf.microperf_style(angle=60, grid_width=4.25, grid_height=3.25,
border_width=8.5, border_height=8.37, tab_radius=1, suffix='A', border=True,
label=True)
# 60-degree hex grid with much fewer points, so we can open it in AI and inspect
hexperf_tiny = perf.microperf_style(angle=60, grid_width=.25, grid_height=.25,
border_width=8.5, border_height=8.37, tab_radius=1, suffix='A', border=True,
label=True)
# generate microperf grids and add to drawing
perf.add_to_drawing([
hexperf_tiny(5, 25, offset_x=20, offset_y=80),
hexperf_tiny(5, 20, offset_x=20, offset_y=60),
hexperf_tiny(5, 15, offset_x=20, offset_y=40),
hexperf_tiny(5, 10, offset_x=20, offset_y=20),
hexperf_tiny(10, 25, offset_x=40, offset_y=80),
hexperf_tiny(10, 20, offset_x=40, offset_y=60),
hexperf_tiny(10, 15, offset_x=40, offset_y=40),
hexperf_tiny(15, 25, offset_x=60, offset_y=80),
hexperf_tiny(15, 20, offset_x=60, offset_y=60),
hexperf_tiny(20, 25, offset_x=80, offset_y=80)
], drawing)
# add 10mmx10mm square for reference
drawing.add(dxf.rectangle((75, 20), 10, 10, layer='ref'))
drawing.add(dxf.text('10mmx10mm', (75, 18), height=1, layer='text'))
drawing.save()
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,
colspacing = w_e+align_space_e, rowspacing = w_e+ align_space_e, layer = layer0, color =am_colour) #bot left
orient_marker3 = dxf.insert(blockname='ame_orient', insert=(am_e_x[0]+orient_marker_size,am_e_y[0]+orient_marker_size), columns = 1 , rows = 1,
colspacing = w_e+align_space_e, rowspacing = w_e+ align_space_e, layer = layer0, color =am_colour) #bot left
from dxfwrite import DXFEngine as dxf
drawing = dxf.drawing(name='layertest.dxf')
#drawing.add_layer('CIRCLE2')
#drawing.add(dxf.circle((10), (10,5), layer='CIRCLE2'))
#drawing.add_layer('CIRCLE')
#drawing.add(dxf.circle((2), (5, 10), layer='CIRCLE'))
drawing.add_layer('RECT')
drawing.add(dxf.rectangle((5, 5) , 6, 6, bgcolor=8, layer='RECT'))
drawing.add_layer('POLY')
polyline= dxf.polyline(linetype='LINE',color=4,layer='POLY')
polyline.add_vertices( [(7,9.5),(6,10), (10,10), (10,6), (6,6),(6,10)])
#polyline.add_vertices( [(5,7.5),(4,8), (8,8), (8,4), (4,4),(4,8)])
#polyline.add_vertices( [(6.5,10), (7,9.5)])
polyline.close(status=True)
polyline.add_vertices( [(5.5,10.5), (10.5,10.5), (10.5,5.5), (5.5,5.5)])
drawing.add(polyline)
drawing.add(dxf.line((7, 9),(6,9.5), color=4))
drawing.add_layer('CIRCLE')
drawing.add(dxf.circle((0.1), (6.5,9.5), layer='CIRCLE'))
drawing.add(dxf.circle((0.1), (9.5,9.5), layer='CIRCLE'))
drawing.add(dxf.circle((0.1), (6.5,6.5), layer='CIRCLE'))
drawing.add(dxf.circle((0.1), (9.5,6.5), layer='CIRCLE'))
drawing.add_layer('TEXTLAYER', color=9)
drawing.add(dxf.text('Layers', (4.9, 6), height=0.5, rotation=90, layer='TEXTLAYER'))
#drawing.add(dxf.dimstyles(4,5))
drawing.save()
try:
import dxfwrite
except ImportError:
# if dxfwrite is not 'installed' append parent dir of __file__ to sys.path
import os
curdir = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.abspath(os.path.join(curdir, os.path.pardir)))
import dxfwrite
from dxfwrite import DXFEngine as dxf
name="rectangle.dxf"
drawing = dxf.drawing(name)
for x in range(10):
for y in range(10):
color = 255 * random()
bgcolor = 255 * random()
rand = random()
# rectangle with only backgound filling
drawing.add(dxf.rectangle((x*3, y*3) , 1.5*rand, .7*rand,
bgcolor=bgcolor))
angle = 90 * random()
# rectangle with only border lines
drawing.add(dxf.rectangle((40+(x*3), y*3) , 1.5*rand, .7*rand,
color=color, rotation=angle))
drawing.save()
print("drawing '%s' created.\n" % name)
def stacks_layers(drawing, startx, starty):
for x in range(0, 5):
centreX = 12+(22.5*x)+startx
centreY = 12+starty
# Main outline
drawing.add(dxf.circle(total_outline_radius, (centreX, centreY), layer='CUTSOUTER', color=5))
# Screw holes
# sin 45 = SQRT(2)/2
sin = math.sqrt(2)/2
offset=(total_outline_radius-1-screw_radius)*sin
drawing.add(dxf.circle(screw_radius, (centreX-offset, centreY-offset), layer='CUTSINNER', color=4))
drawing.add(dxf.circle(screw_radius, (centreX+offset, centreY-offset), layer='CUTSINNER', color=4))
drawing.add(dxf.circle(screw_radius, (centreX-offset, centreY+offset), layer='CUTSINNER', color=4))
drawing.add(dxf.circle(screw_radius, (centreX+offset, centreY+offset), layer='CUTSINNER', color=4))
# not top layer or bottom layer
if ((x != 0) and (x !=4)):
drawing.add(dxf.circle(battery_space/2, (centreX, centreY), layer='CUTSINNER', color=4))
# Number each layer
# drawing.add(dxf.text(str(x), halign=dxfwrite.const.CENTER, valign=dxfwrite.const.MIDDLE, alignpoint=(centreX+2.5, centreY-7.5), height=1.5, layer='ENGRAVE', color=2))
# Slot for bar (the other end of the cufflink
if (x == 4):
# Kurf is ~0.1mm as measured by thickness of two A4 sheets.
drawing.add(dxf.rectangle((centreX-(bar_length/2), centreY-(p_thickness/2)) , bar_length, p_thickness-0.1, layer='CUTSINNER', color=4))
# engrave_text(drawing, centreX, centreY)
# serial_number(drawing, centreX, centreY, "00001")
# Hole for button
if (x == 2):
drawing.add(dxf.line(
(centreX-(p_thickness*1.1)/2, centreY-battery_space/3),
(centreX-(p_thickness*1.1)/2, centreY-total_outline_radius ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX+(p_thickness*1.1)/2, centreY-battery_space/3),
(centreX+(p_thickness*1.1)/2, centreY-total_outline_radius ),
layer='CUTSINNEREARLY', color=3)
)
if ( x == 1):
# Hole for button - but only indent to hold button in
drawing.add(dxf.line(
(centreX-(p_thickness*1.1)/2, centreY-battery_space/3),
(centreX-(p_thickness*1.1)/2, centreY-1-battery_space/2 ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX+(p_thickness*1.1)/2, centreY-battery_space/3),
(centreX+(p_thickness*1.1)/2, centreY-1-battery_space/2 ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX-(p_thickness*1.1)/2, centreY-1-battery_space/2 ),
(centreX+(p_thickness*1.1)/2, centreY-1-battery_space/2 ),
layer='CUTSINNEREARLY', color=3)
)
if ((x != 0) and (x !=4)):
# Tape hole for battery connection
drawing.add(dxf.line(
(centreX-(tape_width)/2, centreY+battery_space/3), # Should do trig, but what the hell
(centreX-(tape_width)/2, centreY+1.5+battery_space/2 ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX+(tape_width)/2, centreY+battery_space/3), # Should do trig, but what the hell
(centreX+(tape_width)/2, centreY+1.5+battery_space/2 ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX-(tape_width)/2, centreY+1.5+battery_space/2 ),
(centreX+(tape_width)/2, centreY+1.5+battery_space/2 ),
layer='CUTSINNEREARLY', color=3)
)
if (x == 6):
drawing.add(dxf.line(
(centreX-(bar_length/2-0.5), centreY+total_outline_radius),
(centreX-(bar_length/2-0.5), centreY-total_outline_radius ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX-(bar_length/2-5), centreY+total_outline_radius),
(centreX-(bar_length/2-5), centreY-total_outline_radius ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX+(bar_length/2-0.5), centreY+total_outline_radius),
(centreX+(bar_length/2-0.5), centreY-total_outline_radius ),
layer='CUTSINNEREARLY', color=3)
)
drawing.add(dxf.line(
(centreX+(bar_length/2-5), centreY+total_outline_radius),
(centreX+(bar_length/2-5), centreY-total_outline_radius ),
layer='CUTSINNEREARLY', color=3)
)
def ExportDXF(self,param):
output = cStringIO.StringIO()
drawing = dxf.drawing('cyclon.dxf')
cx=0
cy=0
cutid=1
nf=[]
nt=[]
nl=[]
#misure utili
htot=param['mantello']['altezza']+param['sezione_interna']['parte_esterna']+param['cono_inferiore']['altezza_totale']
d=param['mantello']['dia']
dint=param['sezione_interna']['dia']
hcono=param['cono_inferiore']['altezza_totale']-param['cono_inferiore']['tronco_diritto']
xz=0
yz=0
#Vista in Pianta
xz=0-d
yz=xz
drawing.add(dxf.circle(d/2,(xz,yz)))
drawing.add(dxf.circle(dint/2,(xz,yz)))
# Vista di Fronte
yz=d*0.5+param['cono_inferiore']['altezza_totale']
h=param['mantello']['altezza']
nf.append([xz-d/2,yz])
nf.append([xz+d/2,yz])
drawing.add(dxf.rectangle((nf[0][0],nf[0][1]),d,h))
nf.append([xz-param['cono_inferiore']['diametro_finale']/2,yz-hcono])
nf.append([xz+param['cono_inferiore']['diametro_finale']/2,yz-hcono])
nf.append([nf[2][0],nf[2][1]-param['cono_inferiore']['tronco_diritto']])
nf.append([nf[3][0],nf[3][1]-param['cono_inferiore']['tronco_diritto']])
drawing.add(dxf.line((nf[0][0],nf[0][1]),(nf[2][0],nf[2][1])))
drawing.add(dxf.line((nf[2][0],nf[2][1]),(nf[3][0],nf[3][1])))
drawing.add(dxf.line((nf[3][0],nf[3][1]),(nf[1][0],nf[1][1])))
drawing.add(dxf.line((nf[2][0],nf[2][1]),(nf[4][0],nf[4][1])))
drawing.add(dxf.line((nf[4][0],nf[4][1]),(nf[5][0],nf[5][1])))
drawing.add(dxf.line((nf[5][0],nf[5][1]),(nf[3][0],nf[3][1])))
# Vista Laterale
for i in nf:
nl.append([i[0]+d*2,i[1]])
drawing.add(dxf.rectangle((nl[0][0],nl[0][1]),d,h))
drawing.add(dxf.line((nl[0][0],nl[0][1]),(nl[2][0],nl[2][1])))
drawing.add(dxf.line((nl[2][0],nl[2][1]),(nl[3][0],nl[3][1])))
drawing.add(dxf.line((nl[3][0],nl[3][1]),(nl[1][0],nl[1][1])))
drawing.add(dxf.line((nl[2][0],nl[2][1]),(nl[4][0],nl[4][1])))
drawing.add(dxf.line((nl[4][0],nl[4][1]),(nl[5][0],nl[5][1])))
drawing.add(dxf.line((nl[5][0],nl[5][1]),(nl[3][0],nl[3][1])))
drawing.save_to_fileobj(output)
dxf_result=[output.getvalue()]
return dxf_result
offset = 30
bend_width = 10
grid_spacing = 120
angle = 15
flag = False
#stroke = svgwrite.rgb(10, 10, 10, '%')
drawing = dxf.drawing('auxetic_test.dxf')
drawing.add(
dxf.rectangle(insert=(-1 * bend_width, -1 * bend_width),
width=grid_spacing * (grid_x) + 2 * bend_width,
height=grid_spacing * (grid_y) + 2 * bend_width))
#dwg.viewbox(width=grid_spacing*(grid_x), height=grid_spacing*(grid_y))
def print_box(grid_x,
grid_y,
offset,
angle,
mirror,
bend_width=5,
rng=grid_spacing,
hinge=0.07):
x_min = grid_x * rng
y_min = grid_y * rng
ref = np.array([x_min, y_min])
def outline(drawing):
drawing.add(dxf.rectangle((0, 0) , 210, 297, layer='OUTLINE', color=1))
from dxfwrite import DXFEngine as dxf
drawing = dxf.drawing("pythondxf.dxf")
# drawing.add_layer('CIRCLE2')
# drawing.add(dxf.circle((10), (10,5), layer='CIRCLE2'))
# drawing.add_layer('CIRCLE')
# drawing.add(dxf.circle((2), (5, 10), layer='CIRCLE'))
drawing.add_layer("RECT")
drawing.add(dxf.rectangle((5, 5), 6, 6, bgcolor=5, layer="RECT"))
drawing.add_layer("POLY")
polyline = dxf.polyline(linetype="LINE")
polyline.add_vertices([(7, 9.5), (6, 10), (10, 10), (10, 6), (6, 6), (6, 10)])
# polyline.add_vertices( [(6.5,10), (7,9.5)])
polyline.close(status=True)
drawing.add(polyline)
drawing.add_layer("CIRCLE")
drawing.add(dxf.circle((0.1), (6.5, 9.5), layer="CIRCLE"))
drawing.add(dxf.circle((0.1), (9.5, 9.5), layer="CIRCLE"))
drawing.add(dxf.circle((0.1), (6.5, 6.5), layer="CIRCLE"))
drawing.add(dxf.circle((0.1), (9.5, 6.5), layer="CIRCLE"))
drawing.save()
def export_via_dxfwrite( dxf_fn, V):
from drawingDimensioning.XMLlib import SvgXMLTreeNode
from drawingDimensioning.svgLib import SvgTextParser, SvgPath, SvgPolygon
from drawingDimensioning.circleLib import fitCircle_to_path, findCircularArcCentrePoint, pointsAlongCircularArc
from numpy import arctan2
from dxfwrite import DXFEngine as dxf
drawing = dxf.drawing( dxf_fn)
pageSvg = open(V.page.PageResult).read()
XML_tree = SvgXMLTreeNode( pageSvg,0)
defaultHeight = 0
defaultFont = 'Verdana'
defaultAnchor = 'left'
def yT(y): #y transform
return 210-y
warningsShown = []
SelectViewObjectPoint_loc = None
for element in XML_tree.getAllElements():
clr_text = None
if 'fill' in element.parms:
clr_text = element.parms['fill']
elif 'style' in element.parms:
for part in element.parms['style'].split(';'):
if part.startswith('stroke:rgb('):
clr_text = part[ len('stroke:'):]
elif part.startswith('font-size'):
defaultHeight = part[len('font-size:')]
elif part.startswith('font-family'):
defaultFont = part[len('font-family:'):]
elif part.startswith('text-anchor'):
defaultAnchor = part[len('text-anchor:'):]
if clr_text == None or clr_text =='none' or not clr_text.startswith('rgb(') :
color_code = 0
else:
#FreeCAD.Console.PrintMessage( "color text: %s\n" % clr_text )
r,g,b = [ int(v.strip()) for v in clr_text[ len('rgb('): clr_text.find(')')].split(',') ]
color_code = colorLookup(r,g,b)[0]
if element.tag == 'circle':
x, y = element.applyTransforms( float( element.parms['cx'] ), float( element.parms['cy'] ) )
r = float( element.parms['r'] )* element.scaling2()
drawing.add( dxf.circle( r, (x,yT(y)), color=color_code) )
elif element.tag == 'line':
x1, y1 = element.applyTransforms( float( element.parms['x1'] ), float( element.parms['y1'] ) )
x2, y2 = element.applyTransforms( float( element.parms['x2'] ), float( element.parms['y2'] ) )
drawing.add( dxf.line( (x1, yT(y1)), (x2, yT(y2)), color=color_code ) )
elif element.tag == 'text' and 'x' in element.parms:
x,y = element.applyTransforms( float( element.parms['x'] ), float( element.parms['y'] ) )
t = SvgTextParser(element.XML[element.pStart: element.pEnd ] )
try:
drawing.add(dxf.text( t.text, insert=(x, yT(y)), height=t.height()*0.8, rotation=t.rotation, layer='TEXTLAYER', color=color_code) )
except ValueError as e:
temp = t.text.replace('<tspan>','')
temp = temp.replace('</tspan>','')
t.text = temp
t.font_size = defaultHeight
t.font_family = defaultFont
if defaultAnchor == 'middle':
shift = t.width()/2.0
x,y = element.applyTransforms( float( element.parms['x'] )-shift, float( element.parms['y'] ) )
drawing.add(dxf.text( temp, insert=(x, yT(y)), height=t.height()*0.8, rotation=t.rotation, layer='TEXTLAYER', color=color_code) )
#FreeCAD.Console.PrintWarning('dxf_export: unable to convert text element "%s": %s, ignoring...\n' % (element.XML[element.pStart: element.pEnd ], str(e) ) )
elif element.tag == 'path':
#FreeCAD.Console.PrintMessage(element.parms['d']+'\n')
path = SvgPath( element )
for line in path.lines:
drawing.add( dxf.line( (line.x1, yT(line.y1)), (line.x2,yT(line.y2)), color=color_code) )
for arc in path.arcs:
if arc.circular:
for r, center, angle1, angle2 in arc.dxfwrite_arc_parms( yT ):
drawing.add( dxf.arc( r, center, angle1, angle2 , color=color_code) )
else:
for x1,y1,x2,y2 in arc.approximate_via_lines( 12 ):
drawing.add( dxf.line( (x1, yT(y1)), (x2, yT(y2)), color=color_code) )
for bezierCurve in path.bezierCurves:
x, y, r, r_error = bezierCurve.fitCircle()
if r_error < 10**-4:
drawing.add( dxf.arc( *bezierCurve.dxfwrite_arc_parms(x, y, r), color=color_code ) )
else:
X,Y = bezierCurve.points_along_curve()
for i in range(len(X) -1):
drawing.add( dxf.line( (X[i], yT(Y[i])), (X[i+1],yT(Y[i+1])), color=color_code ) )
elif element.tag == 'polygon':
p = SvgPolygon( element )
for line in p.lines:
drawing.add( dxf.line( (line.x1, yT(line.y1)), (line.x2,yT(line.y2)), color=color_code) )
elif element.tag == 'rect':
x, y = element.applyTransforms( float( element.parms['x'] ), float( element.parms['y'] ) )
width = float( element.parms['width'] )* element.scaling2()
height = float( element.parms['height'] )* element.scaling2()
drawing.add(dxf.rectangle((x, yT(y)), width, -height, color = color_code) )
elif not element.tag in warningsShown:
FreeCAD.Console.PrintWarning('dxf_export: Warning export of %s elements not supported, ignoring...\n' % element.tag )
warningsShown.append(element.tag)
drawing.save()
FreeCAD.Console.PrintMessage("dxf_export: %s successfully created\n" % dxf_fn)
def create_2D_modelspace_content(dwg):
dwg.add(dxf.rectangle((5,5), 5, 5, color=2))
dwg.add(dxf.circle(2.5, (10, 5), color=3))
triangle = dxf.polyline([(10, 7.5), (15, 5), (15, 10)], color=4)
triangle.close(True)
dwg.add(triangle)
print "Project box dxf file creator - bitx"
print "version 1.0"
print "box dimensions (mm) height: %6.2f width: %6.2f depth: %6.2f tab: %6.2f" % (
h, w, d, t)
print "box dimensions (mm) bend adjustment: %6.2f " % (ba)
'''
Top + Sides
'''
# define top drawing
drawing = dxf.drawing('pb_top.dxf')
alen = w + (2.0 * h) + (2.0 * ba) # adjusted length
# main outline
drawing.add(dxf.rectangle((0, 0), d, alen))
# create layers
drawing.add_layer('bend', color=2)
drawing.add_layer('calibrate', color=3)
drawing.add_layer('drill', color=4)
# add bend lines
acen = alen / 2.0 # center of adjusted length
bendlen = (w + ba / 2.0) / 2.0 # bend length from center
drawing.add(dxf.line((0, acen + bendlen), (d, acen + bendlen), layer='bend'))
drawing.add(dxf.line((0, acen - bendlen), (d, acen - bendlen), layer='bend'))
# add box screw holes (#4 screws)
# side 1
circle_ch(tr, t / 2, h / 2)
circle_ch(tr, d - (t / 2), h / 2)
circle_ch(tr, d / 2, t / 2)
# side 1
#------------------------------------------------------------------------------
# Export Dxf
#------------------------------------------------------------------------------
fileName=("Panel-%dx%d-0.dxf" % (Win,Hin))
fctr=0
while os.path.isfile(fileName) == True:
fctr += 1
fileName=("Panel-%dx%d-%d.dxf" % (Win,Hin,fctr))
print("Outputting DXF - %s" % fileName)
drawing = dxf.drawing(fileName)
for n in range(0,len(x)):
circle = dxf.circle(r[n], (x[n], y[n]))
drawing.add(circle)
drawing.add(dxf.rectangle((0,0),W,H))
drawing.save()
#------------------------------------------------------------------------------
# Write image to jpeg
#------------------------------------------------------------------------------
imageName=("Panel-%dx%d-0.jpg" % (Win,Hin))
fctr=0
while os.path.isfile(imageName) == True:
fctr += 1
imageName=("Panel-%dx%d-%d.jpg" % (Win,Hin,fctr))
print("Outputting JPG - %s" % imageName)
image = pygame.Surface((W, H))
for n in range(0,len(x)):
pygame.draw.circle(image, (255, 255, 255), (x[n], y[n]), r[n], 1)
def create_2D_modelspace_content(dwg):
dwg.add(dxf.rectangle((5, 5), 5, 5, color=2))
dwg.add(dxf.circle(2.5, (10, 5), color=3))
triangle = dxf.polyline([(10, 7.5), (15, 5), (15, 10)], color=4)
triangle.close(True)
dwg.add(triangle)
def get_host_dwg(drawingname):
dwg = dxf.drawing(drawingname)
dwg.add(dxf.text('I AM THE HOST DRAWING', (-0.5, 1.5), 0.5, color=2))
dwg.add(dxf.rectangle((-1,-1), 10, 3, color=2))
return dwg
def create_xref(xrefname):
dwg = dxf.drawing(xrefname)
for x in range(6):
dwg.add(dxf.rectangle((x, 0), 1., 1., color=1+x))
dwg.add(dxf.text('I AM THE XREF', (0.25, 0.25), height=0.5, color=6))
dwg.save()
def stacks_layers(drawing, startx, starty):
for x in range(0, 5):
masterX = 12+(15*x)+startx
masterY = 12+starty
drawing.add(dxf.rectangle((masterX, masterY) , width, height, layer='CUTSOUTER', color=6))
if ((x != 0) and (x !=2) and (x !=4) ):
polyline= dxf.polyline(layer='CUTSINNER', color=5)
polyline.add_vertices( [(masterX+boarder, masterY+boarder),
# Button hole
(masterX+boarder, masterY+boarder+2.5-1),
(masterX+boarder-1, masterY+boarder+2.5-1),
(masterX+boarder-1, masterY+boarder+2.5+1),
(masterX+boarder, masterY+boarder+2.5+1),
# End button hole
(masterX+boarder, masterY+height-boarder-bobble),
(masterX+boarder+bobble, masterY+height-boarder-bobble),
(masterX+boarder+bobble, masterY+height-boarder),
(masterX+width-boarder, masterY+height-boarder),
(masterX+width-boarder, masterY+boarder+bobble),
(masterX+width-boarder-bobble, masterY+boarder+bobble),
(masterX+width-boarder-bobble, masterY+boarder),
(masterX+boarder, masterY+boarder) ])
drawing.add(polyline)
if (x == 0):
# RAG Holes on PCB at 4.5mm, 9mm and 13.5mm
# PCB is width - p_thickness - p_thickness, height - p_thickness - p_thickness
drawing.add(dxf.circle(1, (masterX+width/2, masterY+p_thickness+4.5), layer='CUTSINNER', color=5))
drawing.add(dxf.circle(1, (masterX+width/2, masterY+p_thickness+9.0), layer='CUTSINNER', color=5))
drawing.add(dxf.circle(1, (masterX+width/2, masterY+p_thickness+13.5), layer='CUTSINNER', color=5))
# Backing board!
drawing.add(dxf.rectangle((masterX+p_thickness, masterY+p_thickness) , width-p_thickness*2, height-p_thickness*2, layer='ENGRAVE', color=2))
drawing.add(dxf.rectangle((masterX+p_thickness*1.5, masterY+p_thickness*1.5) , width-p_thickness*3, height-p_thickness*3, layer='ENGRAVE', color=2))
# Button hole
if (x == 2):
drawing.add(dxf.line((masterX, masterY+boarder+2.5-1), (masterX+boarder, masterY+boarder+2.5-1), layer='CUTSINNER', color=5))
drawing.add(dxf.line((masterX, masterY+boarder+2.5+1), (masterX+boarder, masterY+boarder+2.5+1), layer='CUTSINNER', color=5))
# Screws thread holes
if (x == 3):
drawing.add(dxf.circle(screw_radius*1, (masterX+2.75, masterY+height-2.75), layer='CUTSINNER', color=5))
drawing.add(dxf.circle(screw_radius*1, (masterX+width-2.75, masterY+2.75), layer='CUTSINNER', color=5))
if (x == 4):
# mirror as want writing on ourside face
drawing.add(dxf.circle(screw_radius*1, (masterX+width-2.75, masterY+height-2.75), layer='CUTSINNER', color=5))
drawing.add(dxf.circle(screw_radius*1, (masterX+2.75, masterY+2.75), layer='CUTSINNER', color=5))
# Screws head holes
if (x == 2):
polyline= dxf.polyline(layer='CUTSINNER', color=5)
polyline.add_vertices( [(masterX+boarder, masterY+boarder),
(masterX+boarder, masterY+height-boarder-bobble),
(masterX+boarder-1, masterY+height-boarder-bobble),
(masterX+boarder-1, masterY+height-1),
(masterX+boarder+bobble, masterY+height-1),
(masterX+boarder+bobble, masterY+height-boarder),
(masterX+width-boarder, masterY+height-boarder),
(masterX+width-boarder, masterY+boarder+bobble),
(masterX+width-1, masterY+boarder+bobble),
(masterX+width-1, masterY+1),
(masterX+width-boarder-bobble, masterY+1),
(masterX+width-boarder-bobble, masterY+boarder),
(masterX+boarder, masterY+boarder) ])
drawing.add(polyline)
if (x == 4):
# Hole for bar
# Kurf is ~0.1mm as measured by thickness of two A4 sheets.
drawing.add(dxf.rectangle((masterX-(b_len_b/2)+width/2, masterY-(p_thickness/2)+height/2) , b_len_b, p_thickness-0.1, layer='CUTSINNER', color=5))
# logo
engrave_text(drawing, masterX+p_thickness/2+1, masterY+height/2+1.5)
# git version number
engrave_text(drawing, masterX+width-p_thickness/2-1, masterY+height/2, text=get_git_revision_short_hash())
bar(drawing, startx+12+(15*5), starty+12)
button(drawing, startx+12+(15*5), starty+12+bar_height+2)
button(drawing, startx+12+(15*5)+7.5, starty+12+bar_height+2)
