def combine_copper_only(gtl_file, gbl_file, out_copper_only_top, out_copper_only_bottom): copper = load_layer(gtl_file) ctx = GerberCairoContext() ctx.render_layer(copper) ctx.dump(os.path.join(os.path.dirname(__file__), out_copper_only_top)) ctx = GerberCairoContext() copper_bottom = load_layer(gbl_file) ctx.render_layer(copper_bottom, bounds=copper.bounds) ctx.dump(os.path.join(os.path.dirname(__file__), out_copper_only_bottom))
def combine(gtl_file, gts_file, gto_file, txt_file, gtp_file, gbl_file, gbs_file, basedir): # Open the gerber files copper = load_layer(gtl_file) mask = load_layer(gts_file) silk = load_layer(gto_file) drill = load_layer(txt_file) placement = load_layer(gtp_file) # Create a new drawing context ctx = GerberCairoContext() # Draw the copper layer. render_layer() uses the default color scheme for the # layer, based on the layer type. Copper layers are rendered as # Draw the soldermask layer ctx.render_layer(copper) ctx.render_layer(mask) ctx.render_layer(silk, settings=RenderSettings(color=theme.COLORS['white'], alpha=0.85)) ctx.render_layer(drill) # Write output to png file ctx.dump(os.path.join(basedir, "top.png")) # Load the bottom layers copper = load_layer(gbl_file) copper_top = load_layer(gtl_file) mask = load_layer(gbs_file) # Clear the drawing ctx = GerberCairoContext() from gerber.rs274x import read, GerberFile # Render bottom layers ctx.render_layer(copper, bounds=copper_top.bounds) ctx.render_layer(mask) ctx.render_layer(drill, settings=RenderSettings(mirror=True)) # Write png file ctx.dump(os.path.join(basedir, "bottom.png")) copper = load_layer(gtl_file) ctx = GerberCairoContext() ctx.render_layer(copper) ctx.dump(os.path.join(basedir, "top-copper.png")) ctx = GerberCairoContext() copper_bottom = load_layer(gbl_file) ctx.render_layer(copper_bottom, bounds=copper.bounds) ctx.dump(os.path.join(basedir, "bottom-copper.png"))
def generate_template( silk, mask, copper, outline, drill, image, process_resolution: float = 6, # mil resolution_oversampling: float = 10, # times status_print=lambda *args: None): silk, mask, copper, outline, *drill = map( gerber.load_layer_data, [silk, mask, copper, outline, *drill]) silk.layer_class = 'topsilk' mask.layer_class = 'topmask' copper.layer_class = 'top' outline.layer_class = 'outline' f = 1.0 if outline.cam_source.units == 'metric' else 25.4 scale = (1000 / process_resolution) / 25.4 * resolution_oversampling * f # dpmm bounds = outline.cam_source.bounding_box # Create a new drawing context ctx = GerberCairoContext(scale=scale) ctx.render_layer(outline, bounds=bounds) ctx.render_layer(copper, bounds=bounds) ctx.render_layer(mask, bounds=bounds) ctx.render_layer(silk, bounds=bounds) for dr in drill: ctx.render_layer(dr, bounds=bounds) ctx.dump(image)
def __init__(self, device_cfg, output=None): self.device_cfg = device_cfg self.scale = self.device_cfg['size_px']['w'] / self.device_cfg[ 'size_mm']['w'] self.exp_test_start = self.EXP_TEST_START self.exp_test_interval = self.EXP_TEST_INTERVAL self.exp_test_samples = self.EXP_TEST_SAMPLES self.exp_test_tmp_dir = None self.exposure_time = self.DEFAULT_EXPOSURE_TIME self.gbr = None self.drl = None self.output = output if not output: self.output = self.DEFAULT_OUTPUT self.payload_ctx = GerberCairoContext(scale=self.scale) self.white = RenderSettings(color=theme.COLORS['white']) self.black = RenderSettings(color=theme.COLORS['black']) self.pcb_width = None self.pcb_height = None self.photon_template = None if device_cfg['photon_template'] != 'built-in': tpl_path = 'data/{}'.format(device_cfg['photon_template']) self.photon_template = resource_filename('pcb_msla', tpl_path)
def main(): setup() GERBER_FOLDER = os.path.abspath( os.path.join(os.path.dirname(__file__), INPUT_DIR)) # Create a new drawing context ctx = GerberCairoContext() # Create a new PCB instance # pcb = PCB.from_directory(GERBER_FOLDER) outline = load_layer(INPUT_DIR + 'axiom_beta_mixed_panel.boardoutline.ger') outline.layer_class = "outline" top_layer = load_layer(INPUT_DIR + 'axiom_beta_mixed_panel.toplayer.ger') top_layer.layer_class = "toppaste" # top_soldermask_layer = load_layer(INPUT_DIR + 'axiom_beta_mixed_panel.topcream.ger') # top_soldermask_layer.layer_class = "toppaste" top_silkscreen_layer = load_layer( INPUT_DIR + 'axiom_beta_mixed_panel.topsilkscreen.ger') top_silkscreen_layer.layer_class = "topsilk" drill = load_layer(INPUT_DIR + 'axiom_beta_mixed_panel.drills.xln') # Render PCB top view ctx.render_layers({outline, top_layer, top_silkscreen_layer}, OUTPUT_DIR + 'pcb_top.png', theme.THEMES['OSH Park'], verbose=True, max_width=4000, max_height=3000)
def gerberToPNG(filename, png, pixel_mm=0.1): """ Convert to png. Return pixel size in mm. """ try: import gerber except Exception as e: if 'hull' in str(e).lower(): raise Exception( 'Module pyhull not found. Try "pip install pyhull"?') raise Exception( 'The gerber module can be found at https://github.com/curtacircuitos/pcb-tools.' ) try: from gerber.render.cairo_backend import GerberCairoContext except Exception as e: if 'cairo' in str(e).lower(): raise Exception( 'Failed to load gerber.render. Do you have the py2cairo package, which provides the cairo module?' ) raise e # Read gerber and Excellon files data = gerber.read(filename) data.to_metric() # Rendering context ctx = GerberCairoContext(scale=1.0 / pixel_mm) # Scale is pixels/mm # Create SVG image data.render(ctx) ctx.dump(png) return png, np.mean(data.size) / np.mean(ctx.size_in_pixels)
def generate_previews(fab_output_path, preview_output_path): def read(pattern): files = glob(os.path.join(fab_output_path, pattern)) if not files: print("WARNING: Nothing found matching %s" % pattern) return None return gerber.load_layer(files[0]) def save(name): path = os.path.join(preview_output_path, "%s.png" % name) print("Saving preview to %s" % path) ctx.dump(path) def render(pattern, **kw): layer = read(pattern) if layer is None: print("Not rendering %s" % pattern) return ctx.render_layer(layer, verbose=True, **kw) # Rendering context ctx = GerberCairoContext(scale=10) ctx.color = (80. / 255, 80 / 255., 154 / 255.) ctx.drill_color = ctx.color # Edges render("*.gm1") # Copper render("*.gtl") # Mask render("*.gts") # Silk render("*.gto", settings=RenderSettings(color=theme.COLORS['white'], alpha=0.85)) # Drills render("*.drl") save("pcb-front") ctx.clear() # Edges render("*.gm1") # Copper render("*.gbl") # Mask render("*.gbs") # Silk render( "*.gbo", settings=RenderSettings( color=theme.COLORS['white'], alpha=0.85, mirror= True, # for some reason this, but not the other bottom layer files, needs to be flipped horizontally )) # Drills render("*.drl") save("pcb-back")
def final(copper, mask, drill, colour, name, silk=None): new_settings = RenderSettings(color=colour, alpha=0.8) new = GerberCairoContext() new.render_layer(copper, settings=new_settings) new.render_layer(mask, settings=new_settings) if (silk != None): new.render_layer(silk) new.render_layer(drill) new.dump(os.path.join(BASE_DIR, name))
def render_devel_view(self, output_filename=None, quick=False, nox=False): output_filename = '{0}.devel.png'.format(output_filename) ctx = GerberCairoContext() ctx.color = theme.COLORS['fr-4'] ctx.alpha = 1.0 outline = read(self.layers.outline) outline.render(ctx) ctx.color = self.copper_color bottompaste = read(self.layers.bottompaste) bottompaste.render(ctx) ctx.alpha = 0.9 ctx.color = self.silk_color bottomsilk = read(self.layers.bottomsilk) bottomsilk.render(ctx) num_copper_layers = len(self.layers.internal) if self.layers.top is not None: num_copper_layers += 1 if self.layers.bottom is not None: num_copper_layers += 1 ctx.color = self.layer_colors[num_copper_layers - 1] bottom = read(self.layers.bottom) bottom.render(ctx) ctx.alpha = 0.5 for idx, l in enumerate(self.layers.internal): layer = read(l) ctx.color = self.layer_colors[num_copper_layers - 2 - idx] layer.render(ctx) ctx.alpha = 0.9 ctx.color = self.layer_colors[0] top = read(self.layers.top) top.render(ctx) ctx.color = self.silk_color topsilk = read(self.layers.topsilk) topsilk.render(ctx) ctx.color = self.copper_color toppaste = read(self.layers.toppaste) toppaste.render(ctx) ctx.color = theme.COLORS['black'] ctx.alpha = 1.0 drill = read(self.layers.drill) drill.render(ctx) ctx.dump(output_filename)
def render_gerbers_to_image(*gerbers, scale, bounds=None): with tempfile.TemporaryDirectory() as tmpdir: img_file = path.join(tmpdir, 'target.png') fg, bg = gerber.render.RenderSettings( (1, 1, 1)), gerber.render.RenderSettings((0, 0, 0)) ctx = GerberCairoContext(scale=scale) for grb in gerbers: ctx.render_layer(grb, settings=fg, bgsettings=bg, bounds=bounds) ctx.dump(img_file) # Vertically flip exported image to align coordinate systems return cv2.imread(img_file, cv2.IMREAD_GRAYSCALE)[::-1, :]
def generate_mask(outline, target, scale, bounds, debugimg, status_print, extend_overlay_r_mil, subtract_gerber): # Render all gerber layers whose features are to be excluded from the target image, such as board outline, the # original silk layer and the solder paste layer to binary images. with tempfile.TemporaryDirectory() as tmpdir: img_file = path.join(tmpdir, 'target.png') status_print('Combining keepout composite') fg, bg = gerber.render.RenderSettings( (1, 1, 1)), gerber.render.RenderSettings((0, 0, 0)) ctx = GerberCairoContext(scale=scale) status_print(' * outline') ctx.render_layer(outline, settings=fg, bgsettings=bg, bounds=bounds) status_print(' * target layer') ctx.render_layer(target, settings=fg, bgsettings=bg, bounds=bounds) for fn, sub in subtract_gerber: status_print(' * extra layer', os.path.basename(fn)) layer = gerber.loads(sub) ctx.render_layer(layer, settings=fg, bgsettings=bg, bounds=bounds) status_print('Rendering keepout composite') ctx.dump(img_file) # Vertically flip exported image original_img = cv2.imread(img_file, cv2.IMREAD_GRAYSCALE)[::-1, :] f = 1 if outline.units == 'inch' else 25.4 r = 1 + 2 * max(1, int(extend_overlay_r_mil / 1000 * f * scale)) status_print('Expanding keepout composite by', r) # Extend image by a few pixels and flood-fill from (0, 0) to mask out the area outside the outermost outline # This ensures no polygons are generated outside the board even for non-rectangular boards. border = 10 outh, outw = original_img.shape extended_img = np.zeros((outh + 2 * border, outw + 2 * border), dtype=np.uint8) extended_img[border:outh + border, border:outw + border] = original_img debugimg(extended_img, 'outline') cv2.floodFill(extended_img, None, (0, 0), (255, )) original_img = extended_img[border:outh + border, border:outw + border] debugimg(extended_img, 'flooded') # Dilate the white areas of the image using gaussian blur and threshold. Use these instead of primitive dilation # here for their non-directionality. target_img = cv2.blur(original_img, (r, r)) _, target_img = cv2.threshold(target_img, 255 // (1 + r), 255, cv2.THRESH_BINARY) return target_img
def render_top_view(self, output_filename=None, quick=False, nox=False): output_filename = '{0}.top.png'.format(output_filename) ctx = GerberCairoContext() if self.outline_color is not None: ctx.color = self.outline_color if self.outline_alpha is not None: ctx.alpha = self.outline_alpha outline = read(self.layers.outline) outline.render(ctx) if self.copper_color is not None: ctx.color = self.copper_color if self.copper_alpha is not None: ctx.alpha = self.copper_alpha copper = read(self.layers.top) copper.render(ctx) if self.mask_color is not None: ctx.color = self.mask_color if self.mask_alpha is not None: ctx.alpha = self.mask_alpha mask = read(self.layers.topmask) mask.render(ctx, invert=True) if self.silk_color is not None: ctx.color = self.silk_color if self.silk_alpha is not None: ctx.alpha = self.silk_alpha silk = read(self.layers.topsilk) silk.render(ctx) if self.drill_color is not None: ctx.color = self.drill_color if self.drill_alpha is not None: ctx.alpha = self.drill_alpha drill = read(self.layers.drill) drill.render(ctx) ctx.dump(output_filename)
def __init__(self, master=None): super().__init__(master) self.master = master self.pack() self.ctx = GerberCairoContext(8) self.ctx.units = 'metric' self.layers = {} self.components = [] # self.components = self.load_pickplace() self.layer = "TopLayer" # self.geometry("{}x{}".format(self._image_ref.width(), self._image_ref.height())) self.clist = ComponentListGui(self) # self.clist.add_components(self.components, self.layer) self.clist.pack(expand=True, side="right") self.label = tk.Label(self) self.label.pack(expand=True, side="left") # self.draw_component() self.bind('<ButtonRelease-1>', self.draw_component)
#!/usr/bin/env python from gerber import load_layer from gerber.render import RenderSettings, theme from gerber.render.cairo_backend import GerberCairoContext prefix = 'outputs/sonopi-dac-panelized' ctx = GerberCairoContext(scale=40) print('loading ', end='', flush=True) copper = load_layer(prefix + '.GTL') print('.', end='', flush=True) mask = load_layer(prefix + '.GTS') print('.', end='', flush=True) silk = load_layer(prefix + '.GTO') print('.', end='', flush=True) drill = load_layer(prefix + '.TXT') print('.', end='', flush=True) outline = load_layer(prefix + '-fill.GML') print('.', end='', flush=True) print('. end', flush=True) print('drawing ', end='', flush=True) print('.', end='', flush=True) metal_settings = RenderSettings(color=(30.0 / 255.0, 119.0 / 255.0, 93 / 255.0)) bg_settings = RenderSettings(color=(30.0 / 300.0, 110.0 / 300.0, 93 / 300.0)) ctx.render_layer(copper, settings=metal_settings, bgsettings=bg_settings) print('.', end='', flush=True)
""" This example demonstrates the use of pcb-tools with cairo to render composite images using the PCB interface """ import os from gerber import PCB from gerber.render import theme from gerber.render.cairo_backend import GerberCairoContext GERBER_FOLDER = os.path.abspath(os.path.join(os.path.dirname(__file__), 'gerbers')) # Create a new drawing context ctx = GerberCairoContext() # Create a new PCB instance pcb = PCB.from_directory(GERBER_FOLDER) # Render PCB top view ctx.render_layers(pcb.top_layers, os.path.join(os.path.dirname(__file__), 'pcb_top.png',), theme.THEMES['OSH Park'], max_width=800, max_height=600) # Render PCB bottom view ctx.render_layers(pcb.bottom_layers, os.path.join(os.path.dirname(__file__), 'pcb_bottom.png'), theme.THEMES['OSH Park'], max_width=800, max_height=600) # Render copper layers only
""" import gerber from gerber.render.cairo_backend import GerberCairoContext from gerber.render import RenderSettings, theme from gerber import load_layer import os BASE_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__),'gerbers')) copper=load_layer(os.path.join(BASE_DIR,'copper.GTL')) mask=load_layer(os.path.join(BASE_DIR,'soldermask.GTS')) silk=load_layer(os.path.join(BASE_DIR,'silkscreen.GTO')) drill=load_layer(os.path.join(BASE_DIR,'ncdrill.DRD')) new=GerberCairoContext() new_settings=RenderSettings(color=theme.COLORS['red'],alpha=0.8) white_text_settings=RenderSettings(color=theme.COLORS['white'],alpha=0.8) new.render_layer(copper,settings=new_settings) new.render_layer(mask,settings=new_settings) new.render_layer(silk,settings=white_text_settings) new.render_layer(drill) new.dump(os.path.join(BASE_DIR,'front.png')) new.clear() copper_bottom=load_layer(os.path.join(BASE_DIR,'bottom_copper.GBL')) mask_bottom=load_layer(os.path.join(BASE_DIR,'bottom_mask.GBS')) new.render_layer(copper_bottom,settings=new_settings) new.render_layer(mask_bottom,settings=new_settings)
def render(BASE_FOLDER): ppi = 1000 # font_size_in = 0.02 # font_color = 'rgb(255, 0, 0)' # textbox_color = "skyblue" Image.MAX_IMAGE_PIXELS = 1000000000 if os.path.exists(os.path.join(BASE_FOLDER, 'board_top.png')): os.remove(os.path.join(BASE_FOLDER, 'board_top.png')) if os.path.exists(os.path.join(BASE_FOLDER, 'board_bottom.png')): os.remove(os.path.join(BASE_FOLDER, 'board_bottom.png')) print('Processing ', BASE_FOLDER) # Open the gerber files copper = load_layer(os.path.join(BASE_FOLDER, 'GerberFiles\copper_top.gbr')) mask = load_layer( os.path.join(BASE_FOLDER, 'GerberFiles\soldermask_top.gbr')) silk = load_layer( os.path.join(BASE_FOLDER, 'GerberFiles\silkscreen_top.gbr')) outline = load_layer(os.path.join(BASE_FOLDER, 'GerberFiles\profile.gbr')) drill = load_layer(os.path.join(BASE_FOLDER, 'DrillFiles\drill_1_16.xln')) # Create a new drawing context ctx = GerberCairoContext(scale=ppi) # Draw the outline first, so it establishes the outer dimensions ctx.render_layer(outline, settings=RenderSettings(color=theme.COLORS['black'], alpha=0.85)) # Draw the copper layer. render_layer() uses the default color scheme for the # layer, based on the layer type. Copper layers are rendered as ctx.render_layer(copper, settings=RenderSettings(color=theme.COLORS['hasl copper'], alpha=0.85)) # Draw the soldermask layer ctx.render_layer(mask, settings=RenderSettings( color=theme.COLORS['green soldermask'], invert=True, alpha=0.8)) # Draw the silkscreen layer, and specify the rendering settings to use ctx.render_layer(silk, settings=RenderSettings(color=theme.COLORS['white'], alpha=0.85)) # Draw the drill layer ctx.render_layer(drill) # Draw the outline again so it's on top of everything ctx.render_layer(outline, settings=RenderSettings(color=theme.COLORS['black'], alpha=0.85)) size_px = ctx.size_in_pixels origin_px = ctx.origin_in_pixels origin_in = ctx.origin_in_inch print(f"size: {ctx.size_in_inch} in / {ctx.size_in_pixels} px ({ppi} PPI)") print(f"origin: {ctx.origin_in_inch} in / {ctx.origin_in_pixels} px") config = configparser.ConfigParser() config['DIMENSIONS'] = { 'SIZE_X_IN': ctx.size_in_inch[0], 'SIZE_Y_IN': ctx.size_in_inch[1], 'SIZE_X_PX': ctx.size_in_pixels[0], 'SIZE_Y_PX': ctx.size_in_pixels[1], 'PPI': ppi, 'ORIGIN_X_IN': ctx.origin_in_inch[0], 'ORIGIN_Y_IN': ctx.origin_in_inch[1] } mtime = 0 for filename in os.listdir(os.path.join(BASE_FOLDER, 'GerberFiles')): mtime = max( mtime, os.path.getmtime(os.path.join(BASE_FOLDER, 'GerberFiles', filename))) print('Latest file modification time: ', mtime) config['OTHER'] = {'GERBERS_LASTMODIFIED': mtime} with open(os.path.join(BASE_FOLDER, 'board.ini'), 'w') as configfile: config.write(configfile) # Write output to png file ctx.dump(os.path.join(BASE_FOLDER, 'board_top.png'), verbose=True) # Load the bottom layers copper = load_layer( os.path.join(BASE_FOLDER, 'GerberFiles\copper_bottom.gbr')) mask = load_layer( os.path.join(BASE_FOLDER, 'GerberFiles\soldermask_bottom.gbr')) silk = load_layer( os.path.join(BASE_FOLDER, 'GerberFiles\silkscreen_bottom.gbr')) # Clear the drawing ctx.clear() # Render bottom layers ctx.render_layer(outline, settings=RenderSettings(color=theme.COLORS['black'], mirror=True, alpha=0.85)) ctx.render_layer(copper, settings=RenderSettings(color=theme.COLORS['hasl copper'], mirror=True, alpha=0.85)) ctx.render_layer(mask, settings=RenderSettings( color=theme.COLORS['green soldermask'], mirror=True, invert=True, alpha=0.8)) ctx.render_layer(silk, settings=RenderSettings(color=theme.COLORS['white'], mirror=True, alpha=0.85)) ctx.render_layer(drill, settings=RenderSettings(mirror=True)) ctx.render_layer(outline, settings=RenderSettings(color=theme.COLORS['black'], mirror=True, alpha=0.85)) # Write png file ctx.dump(os.path.join(BASE_FOLDER, 'board_bottom.png'), verbose=True)
legend = load_layer('gerber_files/silkscreen.GTO') drill = load_layer('gerber_files/ncdrill.DRD') #Bottom View Layers copper_btm = load_layer('gerber_files/bottom_copper.GBL') soldermask_btm = load_layer('gerber_files/bottom_mask.GBS') ## Color Settings mask_settings = RenderSettings(color=theme.COLORS['red soldermask'], alpha=0.5, invert=True) legend_settings = RenderSettings(color=theme.COLORS['white'], alpha=0.8) ## Rendering #Top View cont = GerberCairoContext() cont.render_layer(copper) cont.render_layer(soldermask, settings=mask_settings) cont.render_layer(legend, settings=legend_settings) cont.render_layer(drill) cont.dump('gen_images/redpcb.png') #Clear cont cont.clear() #Bottom View cont.render_layer(copper_btm) cont.render_layer(soldermask_btm, settings=mask_settings) cont.dump('gen_images/redpcb_bottom.png')