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")
Exemplo n.º 2
0
print('.', end='', flush=True)

our_settings = RenderSettings(color=theme.COLORS['white'], alpha=0.80)
ctx.render_layer(silk, settings=our_settings)
print('.', end='', flush=True)

ctx.render_layer(outline)
print('.', end='', flush=True)
ctx.render_layer(drill)
print('.', end='', flush=True)
print('. end', flush=True)

print('dumping ...')
ctx.dump('outputs/board-top.png')

ctx.clear()
print('loading bottom ', end='', flush=True)
copper = load_layer(prefix + '.GBL')
print('.', end='', flush=True)
mask = load_layer(prefix + '.GBS')
print('.', end='', flush=True)
silk = load_layer(prefix + '.GBO')
print('.', end='', flush=True)
print('. end', flush=True)

print('drawing bottom ', end='', flush=True)
ctx.render_layer(copper, settings=metal_settings, bgsettings=bg_settings)
print('.', end='', flush=True)
ctx.render_layer(mask, settings=copper_settings)
print('.', end='', flush=True)
ctx.render_layer(silk, settings=our_settings)
Exemplo n.º 3
0
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)
class PcbGui(tk.Frame):
    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)

    def select_gerber_folder(self):
        dir = tk.filedialog.askdirectory(title="Select folder with Gerbers")
        self.layers = {}
        for infile in listdir(dir):
            path = os.path.join(dir, infile)
            if infile.lower().endswith('gbl'):
                self.layers['gbl'] = gerber.load_layer(path)
            if infile.lower().endswith('gtl'):
                self.layers['gtl'] = gerber.load_layer(path)
            if infile.lower().endswith('gtp'):
                self.layers['gtp'] = gerber.load_layer(path)
        self.draw_component()

    def set_layer(self, layer):
        self.layer = layer
        self.draw_component()
        self.clist.add_components(self.components, self.layer)

    def menubar(self, root):
        menubar = tk.Menu(root)
        pageMenu = tk.Menu(menubar)
        pageMenu.add_command(label="Open Gerber folder",
                             command=self.select_gerber_folder)
        pageMenu.add_command(label="Open pick and place file",
                             command=self.load_pickplace)
        menubar.add_cascade(label="File", menu=pageMenu)

        layerMenu = tk.Menu(menubar)
        layerMenu.add_radiobutton(label="Top Layer",
                                  command=lambda: self.set_layer("TopLayer"))
        layerMenu.add_radiobutton(
            label="Bottom Layer",
            command=lambda: self.set_layer("BottomLayer"))
        menubar.add_cascade(label="Layer", menu=layerMenu)

        helpMenu = tk.Menu(menubar, name="help")
        helpMenu.add_command(label="About")
        menubar.add_cascade(label="Help", menu=helpMenu)
        return menubar

    # def load_gerber(self):
    #     self.layers = {}
    #     self.layers.append(gerber.load_layer('example.GTL'))
    # self.ctx.render_layers(layers, buffer, max_width=self.w, max_height=self.h, verbose=True)

    def draw_component(self, event=None):
        self.ctx.clear()

        if len(self.layers) > 0:
            if self.layer == "TopLayer":
                copper_settings = RenderSettings(color=theme.COLORS['black'],
                                                 alpha=0.8,
                                                 mirror=False)
                self.ctx.render_layer(self.layers["gtl"],
                                      settings=copper_settings,
                                      verbose=True)
                self.ctx.new_render_layer(mirror=False)
            if self.layer == "BottomLayer":
                copper_settings = RenderSettings(color=theme.COLORS['black'],
                                                 alpha=0.8,
                                                 mirror=True)
                self.ctx.render_layer(self.layers["gbl"],
                                      settings=copper_settings)
                self.ctx.new_render_layer(mirror=True)

            self.ctx._color = (1.0, 0.0, 1.0)
            layer = self.layer
            if self.clist.tb.selected_row != None:
                part_number = self.clist.tb.selected_row['PN']
            else:
                part_number = None
            for c in self.components:
                if (c['layer'] == layer) and (c['part_number'] == part_number):
                    print("{} {}".format(c['x_mm'], c['y_mm']))
                    self.ctx.render(
                        gerber.primitives.Circle((c['x_mm'], c['y_mm']), 1))
            self.ctx.flatten()
            buffer = BytesIO()
            self.ctx.dump(buffer)
            img = ImageTk.PhotoImage(Image.open(buffer))
            self.label.configure(image=img)
            self.label.image = img

    def load_pickplace(self):
        filename = tk.filedialog.askopenfilename(
            title="Select pick and place file")
        components = []
        filetype = "Kicad"
        with open(filename, "r") as ppfile:
            header_read = False
            for line in ppfile:
                line = shlex.split(line)
                if len(line) > 0:
                    if header_read == False:
                        # Try to determine the file type based on the contents
                        if line[0] == "Altium":
                            filetype = "Altium"
                        if line[0] == "Designator" or line[0] == "#":
                            header_read = True
                    else:
                        if filetype == "Altium":
                            component = {}
                            component['designator'] = line[0]
                            component['part_number'] = line[1]
                            component['x_mm'] = float(line[4][:-2])
                            component['y_mm'] = float(line[5][:-2])
                            component['layer'] = line[2]
                            component['description'] = line[7]
                            components.append(component)
                        elif filetype == "Kicad":
                            if len(line) > 6:
                                print(line)
                                component = {}
                                component['designator'] = line[0]
                                component['part_number'] = line[1]
                                component['x_mm'] = float(line[3])
                                component['y_mm'] = float(line[4])
                                component['layer'] = "TopLayer" if line[
                                    6] == "top" else "BottomLayer"
                                if component['layer'] == "BottomLayer":
                                    component['x_mm'] *= -1
                                component['description'] = line[2]
                                components.append(component)
        self.components = components
        self.clist.add_components(self.components, self.layer)
Exemplo n.º 5
0
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)
new.render_layer(drill)

new.dump(os.path.join(BASE_DIR,'back.png')) 



Exemplo n.º 6
0

# The default style can be overridden by passing a RenderSettings instance to
# render_layer().
# First, create a settings object:
our_settings = RenderSettings(color=theme.COLORS['white'], alpha=0.85)

# Draw the silkscreen layer, and specify the rendering settings to use
ctx.render_layer(silk, settings=our_settings)

# Draw the drill layer
ctx.render_layer(drill)

# Write output to png file
ctx.dump(os.path.join(os.path.dirname(__file__), 'cairo_example.png'))

# Load the bottom layers
copper = load_layer(os.path.join(GERBER_FOLDER, 'bottom_copper.GBL'))
mask = load_layer(os.path.join(GERBER_FOLDER, 'bottom_mask.GBS'))

# Clear the drawing
ctx.clear()

# Render bottom layers
ctx.render_layer(copper)
ctx.render_layer(mask)
ctx.render_layer(drill)

# Write png file
ctx.dump(os.path.join(os.path.dirname(__file__), 'cairo_bottom.png'))
Exemplo n.º 7
0
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')