From 606e41d4b7969c1f1d0a935aa1e957631e71cd39 Mon Sep 17 00:00:00 2001 From: jaseg Date: Fri, 21 Jan 2022 21:15:53 +0100 Subject: Layer merging WIP --- gerbonara/gerber/layers.py | 252 +++++++++++++++++++++++++++++++++++++-------- 1 file changed, 211 insertions(+), 41 deletions(-) (limited to 'gerbonara/gerber/layers.py') diff --git a/gerbonara/gerber/layers.py b/gerbonara/gerber/layers.py index 9e34bd8..26dd9c1 100644 --- a/gerbonara/gerber/layers.py +++ b/gerbonara/gerber/layers.py @@ -23,6 +23,20 @@ from collections import namedtuple from .excellon import ExcellonFile from .ipc356 import IPCNetlist + +STANDARD_LAYERS = [ + 'outline', + 'top copper', + 'top mask', + 'top silk', + 'top paste', + 'bottom copper', + 'bottom mask', + 'bottom silk', + 'bottom paste', + ] + + def match_files(filenames): matches = {} for generator, rules in MATCH_RULES.items(): @@ -84,51 +98,43 @@ def layername_autoguesser(fn): fn, _, _ext = fn.lower().rpartition('.') side, use = 'unknown', 'unknown' - hint = '' if re.match('top|front|pri?m?(ary)?', fn): side = 'top' use = 'copper' - if re.match('bot|bottom|back|sec(ondary)?', fn): + if re.match('bot(tom)?|back|sec(ondary)?', fn): side = 'bottom' use = 'copper' if re.match('silks?(creen)?', fn): use = 'silk' + elif re.match('(solder)?paste', fn): use = 'paste' + elif re.match('(solder)?mask', fn): use = 'mask' - elif (m := re.match('([tbcps])sm([tbcps])', fn)): - use = 'mask' - hint = m[1] + m[2] - elif (m := re.match('([tbcps])sp([tbcps])', fn)): - use = 'paste' - hint = m[1] + m[2] - elif (m := re.match('([tbcps])sl?k([tbcps])', fn)): - use = 'silk' - hint = m[1] + m[2] - elif (m := re.match('(la?y?e?r?|inn?e?r?)\W*([0-9]+)', fn)): + + elif (m := re.match('(la?y?e?r?|in(ner)?)\W*(?P[0-9]+)', fn)): use = 'copper' - side = f'inner_{m[1]}' + side = f'inner_{m["num"]:02d}' + elif re.match('film', fn): use = 'copper' - elif re.match('drill|rout?e?|outline'): + + elif re.match('out(line)?'): + use = 'drill' + side = 'outline' + + elif re.match('drill|rout?e?'): use = 'drill' side = 'unknown' if re.match('np(th)?|(non|un)\W*plated|(non|un)\Wgalv', fn): side = 'nonplated' + elif re.match('pth|plated|galv', fn): side = 'plated' - if side is None and hint: - hint = set(hint) - if len(hint) == 1: - and hint[0] in 'tpc': - side = 'top' - else - side = 'bottom' - return f'{use} {side}' class LayerStack: @@ -175,35 +181,199 @@ class LayerStack: if any(len(value) > 1 for value in filemap.values()): raise SystemError('Ambgiuous layer names') - filemap = { key: values[0] for key, value in filemap.items() } + drill_layers = [] + layers = { key: None for key in STANDARD_LAYERS } + for key, paths in filemap.items(): + if len(paths) > 1 and not 'drill' in key: + raise ValueError(f'Multiple matching files found for {key} layer: {", ".join(value)}') + + for path in paths: + if 'outline' in key or 'drill' in key and identify_file(path.read_text()) != 'gerber': + if 'nonplated' in key: + plated = False + elif 'plated' in key: + plated = True + else: + plated = None + layer = ExcellonFile.open(path, plated=plated, settings=excellon_settings) + else: + layer = GerberFile.open(path) + + if key == 'drill outline': + layers['outline'] = layer + + elif 'drill' in key: + drill_layers.append(layer) - layers = {} - for key, path in filemap.items(): - if 'outline' in key or 'drill' in key and identify_file(path.read_text()) != 'gerber': - if 'nonplated' in key: - plated = False - elif 'plated' in key: - plated = True else: - plated = None - layers[key] = ExcellonFile.open(path, plated=plated, settings=excellon_settings) - else: - layers[key] = GerberFile.open(path) + side, _, use = key.partition(' ') + layers[(side, use)] = layer - hints = { layers[key].generator_hints } + { generator } - if len(hints) > 1: - warnings.warn('File identification returned ambiguous results. Please raise an issue on the gerbonara ' - 'tracker and if possible please provide these input files for reference.') + hints = { layer.generator_hints } + { generator } + if len(hints) > 1: + warnings.warn('File identification returned ambiguous results. Please raise an issue on the gerbonara ' + 'tracker and if possible please provide these input files for reference.') board_name = common_prefix([f.name for f in filemap.values()]) board_name = re.subs('^\W+', '', board_name) board_name = re.subs('\W+$', '', board_name) - return kls(layers, board_name=board_name) + return kls(layers, drill_layers, board_name=board_name) - def __init__(self, layers, board_name=None): - self.layers = layers + def __init__(self, graphic_layers, drill_layers, board_name=None): + self.graphic_layers = graphic_layers + self.-drill_layers = drill_layers self.board_name = board_name + def merge_drill_layers(self): + target = ExcellonFile(comments='Drill files merged by gerbonara') + + for layer in self.drill_layers: + if isinstance(layer, GerberFile): + layer = layer.to_excellon() + + target.merge(layer) + + self.drill_layers = [target] + + def normalize_drill_layers(self): + drill_pth, drill_npth, drill_aux = [], [], [] + + for layer in self.drill_layers: + if isinstance(layer, GerberFile): + layer = layer.to_excellon() + + if layer.is_plated: + drill_pth.append(layer) + elif layer.is_nonplated: + drill_pth.append(layer) + else: + drill_aux.append(layer) + + pth_out, *rest = drill_pth or [ExcellonFile()] + for layer in rest: + pth_out.merge(layer) + + npth_out, *rest = drill_npth or [ExcellonFile()] + for layer in rest: + npth_out.merge(layer) + + unknown_out = ExcellonFile() + for layer in drill_aux: + for obj in layer.objects: + if obj.plated is None: + unknown_out.append(obj) + elif obj.plated: + pth_out.append(obj) + else: + npth_out.append(obj) + + self.drill_pth, self.drill_npth = pth_out, npth_out + self.drill_unknown = unknown_out if unknown_out else None + self._drill_layers = [] + + @property + def drill_layers(self): + if self._drill_layers: + return self._drill_layers + return [self.drill_pth, self.drill_npth, self.drill_unknown] + + @drill_layers.setter + def drill_layers(self, value): + self._drill_layers = value + self.drill_pth = self.drill_npth = self.drill_unknown = None + def __len__(self): return len(self.layers) + def __getitem__(self, index): + if isinstance(index, str): + side, _, use = index.partition(' ') + return self.layers.get((side, use)) + + elif isinstance(index, tuple): + return self.layers.get(index) + + return self.copper_layers[index] + + @property + def copper_layers(self): + copper_layers = [ (key, layer) for key, layer in self.layers.items() if key.endswith('copper') ] + + def sort_layername(val): + key, _layer = val + if key.startswith('top'): + return -1 + if key.startswith('bottom'): + return 1e99 + assert key.startswith('inner_') + return int(key[len('inner_'):]) + + return [ layer for _key, layer in sorted(copper_layers, key=sort_layername) ] + + @property + def top_side(self): + return { key: self[key] for key in ('top copper', 'top mask', 'top silk', 'top paste', 'outline') } + + @property + def bottom_side(self): + return { key: self[key] for key in ('bottom copper', 'bottom mask', 'bottom silk', 'bottom paste', 'outline') } + + @property + def outline(self): + return self['outline'] + + def _merge_layer(self, target, source): + if source is None: + return + + if self[target] is None: + self[target] = source + + else: + self[target].merge(source) + + def merge(self, other): + all_keys = set(self.layers.keys()) | set(other.layers.keys()) + exclude = { key.split() for key in STANDARD_LAYERS } + all_keys = { key for key in all_keys if key not in exclude } + if all_keys: + warnings.warn('Cannot merge unknown layer types: {" ".join(all_keys)}') + + for side in 'top', 'bottom': + for use in 'copper', 'mask', 'silk', 'paste': + self._merge_layer((side, use), other[side, use]) + + our_inner, their_inner = self.copper_layers[1:-1], other.copper_layers[1:-1] + + if bool(our_inner) != bool(their_inner): + warnings.warn('Merging board without inner layers into board with inner layers, inner layers will be empty on first board.') + + elif our_inner and their_inner: + warnings.warn('Merging boards with different inner layer counts. Will fill inner layers starting at core.') + + diff = len(our_inner) - len(their_inner) + their_inner = ([None] * max(0, diff//2)) + their_inner + ([None] * max(0, diff//2)) + our_inner = ([None] * max(0, -diff//2)) + their_inner + ([None] * max(0, -diff//2)) + + new_inner = [] + for ours, theirs in zip(our_inner, their_inner): + if ours is None: + new_inner.append(theirs) + elif theirs is None: + new_inner.append(ours) + else: + ours.merge(theirs) + new_inner.append(ours) + + for i, layer in enumerate(new_inner, start=1): + self[f'inner_{i} copper'] = layer + + self._merge_layer('outline', other['outline']) + + self.normalize_drill_layers() + other.normalize_drill_layers() + + self.drill_pth.merge(other.drill_pth) + self.drill_npth.merge(other.drill_npth) + self.drill_unknown.merge(other.drill_unknown) + -- cgit