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)