Add missing protoboard file, add powered proto layout

1 files changed, 341 insertions, 0 deletions

diff --git a/gerbonara/cad/protoboard.py b/gerbonara/cad/protoboard.py
new file mode 100644
index 0000000..6ae8914
--- /dev/null
+++ b/gerbonara/cad/protoboard.py
@@ -0,0 +1,341 @@
+
+import sys
+import re
+import math
+from copy import copy, deepcopy
+import warnings
+
+from .primitives import *
+from ..graphic_objects import Region
+from ..apertures import RectangleAperture, CircleAperture
+
+
+class ProtoBoard(Board):
+    def __init__(self, w, h, content, margin=None, corner_radius=None, mounting_hole_dia=None, mounting_hole_offset=None, unit=MM):
+        corner_radius = corner_radius or unit(1.5, MM)
+        super().__init__(w, h, corner_radius, unit=unit)
+        self.margin = margin or unit(2, MM)
+        self.content = content
+
+        if mounting_hole_dia:
+            mounting_hole_offset = mounting_hole_offset or mounting_hole_dia*2
+            ko = mounting_hole_offset*2
+
+            self.add(Hole(mounting_hole_offset, mounting_hole_offset, mounting_hole_dia, unit=unit))
+            self.add(Hole(w-mounting_hole_offset, mounting_hole_offset, mounting_hole_dia, unit=unit))
+            self.add(Hole(mounting_hole_offset, h-mounting_hole_offset, mounting_hole_dia, unit=unit))
+            self.add(Hole(w-mounting_hole_offset, h-mounting_hole_offset, mounting_hole_dia, unit=unit))
+
+            self.keepouts.append(((0, 0), (ko, ko)))
+            self.keepouts.append(((w-ko, 0), (w, ko)))
+            self.keepouts.append(((0, h-ko), (ko, h)))
+            self.keepouts.append(((w-ko, h-ko), (w, h)))
+
+        self.generate()
+
+    def generate(self, unit=MM):
+        bbox = ((self.margin, self.margin), (self.w-self.margin, self.h-self.margin))
+        bbox = unit.convert_bounds_from(self.unit, bbox)
+        for obj in self.content.generate(bbox, unit):
+            self.add(obj, keepout_errors='skip')
+
+
+class PropLayout:
+    def __init__(self, content, direction, proportions):
+        self.content = list(content)
+        if direction not in ('h', 'v'):
+            raise ValueError('direction must be one of "h", or "v".')
+        self.direction = direction
+        self.proportions = list(proportions)
+        if len(content) != len(proportions):
+            raise ValueError('proportions and content must have same length')
+
+    def generate(self, bbox, unit=MM):
+        for bbox, child in self.layout_2d(bbox, unit):
+            yield from child.generate(bbox, unit)
+
+    def fit_size(self, w, h, unit=MM):
+        widths = []
+        heights = []
+        for ((x_min, y_min), (x_max, y_max)), child in self.layout_2d(((0, 0), (w, h)), unit):
+            if not isinstance(child, EmptyProtoArea):
+                widths.append(x_max - x_min)
+                heights.append(y_max - y_min)
+        if self.direction == 'h':
+            return sum(widths), max(heights)
+        else:
+            return max(widths), sum(heights)
+
+    def layout_2d(self, bbox, unit=MM):
+        (x, y), (w, h) = bbox
+        w, h = w-x, h-y
+
+        actual_l = 0
+        target_l = 0
+
+        for l, child in zip(self.layout(w if self.direction == 'h' else h, unit), self.content):
+            this_x, this_y = x, y
+            this_w, this_h = w, h
+            target_l += l
+
+            if self.direction == 'h':
+                this_w = target_l - actual_l
+            else:
+                this_h = target_l - actual_l
+
+            this_w, this_h = child.fit_size(this_w, this_h, unit)
+
+            if self.direction == 'h':
+                x += this_w
+                actual_l += this_w
+                this_h = h
+            else:
+                y += this_h
+                actual_l += this_h
+                this_w = w
+
+            yield ((this_x, this_y), (this_x+this_w, this_y+this_h)), child
+
+    def layout(self, length, unit=MM):
+        out = [ eval_value(value, MM(length, unit)) for value in self.proportions ]
+        total_length = sum(value for value in out if value is not None)
+        if length - total_length < -1e-6:
+            raise ValueError(f'Proportions sum to {total_length} mm, which is greater than the available space of {length} mm.')
+
+        leftover = length - total_length
+        sum_props = sum( (value or 1.0) for value in self.proportions if not isinstance(value, str) )
+        return [ unit(leftover * (value or 1.0) / sum_props if not isinstance(value, str) else calculated, MM)
+                for value, calculated in zip(self.proportions, out) ]
+
+    def __str__(self):
+        children = ', '.join( f'{elem}:{width}' for elem, width in zip(self.content, self.proportions))
+        return f'PropLayout[{self.direction.upper()}]({children})'
+
+
+class TwoSideLayout:
+    def __init__(self, top, bottom):
+        self.top, self.bottom = top, bottom
+
+        if not top.single_sided or not bottom.single_sided:
+            warnings.warn('Two-sided pattern used on one side of a TwoSideLayout')
+
+    def fit_size(self, w, h, unit=MM):
+        w1, h1 = self.top.fit_size(w, h, unit)
+        w2, h2 = self.bottom.fit_size(w, h, unit)
+        if isinstance(self.top, EmptyProtoArea):
+            if isinstance(self.bottom, EmptyProtoArea):
+                return w1, h1
+            return w2, h2
+        if isinstance(self.bottom, EmptyProtoArea):
+            return w1, h1
+        return max(w1, w2), max(h1, h2)
+
+    def generate(self, bbox, unit=MM):
+        yield from self.top.generate(bbox, unit)
+        for obj in self.bottom.generate(bbox, unit):
+            obj.side = 'bottom'
+            yield obj
+
+
+class PatternProtoArea:
+    def __init__(self, pitch_x, pitch_y=None, obj=None, unit=MM):
+        self.pitch_x = pitch_x
+        self.pitch_y = pitch_y or pitch_x
+        self.obj = obj
+        self.unit = unit
+
+    def fit_size(self, w, h, unit=MM):
+        (min_x, min_y), (max_x, max_y) = self.fit_rect(((0, 0), (w, h)))
+        return max_x-min_x, max_y-min_y
+
+    def fit_rect(self, bbox, unit=MM):
+        (x, y), (w, h) = bbox
+        w, h = w-x, h-y
+
+        w_mod = round((w + 5e-7) % unit(self.pitch_x, self.unit), 6)
+        h_mod = round((h + 5e-7) % unit(self.pitch_y, self.unit), 6)
+        w_fit, h_fit = round(w - w_mod, 6), round(h - h_mod, 6)
+
+        x = x + (w-w_fit)/2
+        y = y + (h-h_fit)/2
+        return (x, y), (x+w_fit, y+h_fit)
+
+    def generate(self, bbox, unit=MM):
+        (x, y), (w, h) = bbox
+        w, h = w-x, h-y
+        n_x = int(w//unit(self.pitch_x, self.unit))
+        n_y = int(h//unit(self.pitch_y, self.unit))
+        off_x = (w % unit(self.pitch_x, self.unit)) / 2
+        off_y = (h % unit(self.pitch_y, self.unit)) / 2
+
+        for i in range(n_x):
+            for j in range(n_y):
+                if hasattr(self.obj, 'inst'):
+                    inst = self.obj.inst(i, j)
+                else:
+                    inst = copy(self.obj)
+
+                inst.x = inst.unit(off_x + x, unit) + (i + 0.5) * inst.unit(self.pitch_x, self.unit)
+                inst.y = inst.unit(off_y + y, unit) + (j + 0.5) * inst.unit(self.pitch_y, self.unit)
+                yield inst
+
+    @property
+    def single_sided(self):
+        return self.obj.single_sided
+
+
+class EmptyProtoArea:
+    def __init__(self, copper_fill=False):
+        self.copper_fill = copper_fill
+
+    def fit_size(self, w, h, unit=MM):
+        return w, h
+
+    def generate(self, bbox, unit=MM):
+        if self.copper:
+            (min_x, min_y), (max_x, max_y) = bbox
+            yield ObjectGroup(top_copper=[Region([(min_x, min_y), (max_x, min_y), (max_x, max_y), (min_x, max_y)],
+                                                unit=unit, polarity_dark=True)])
+
+    @property
+    def single_sided(self):
+        return True
+
+
+class ManhattanPads(ObjectGroup):
+    def __init__(self, w, h=None, gap=0.2, unit=MM):
+        super().__init__(0, 0)
+        h = h or w
+        self.gap = gap
+        self.unit = unit
+
+        p = (w-2*gap)/2
+        q = (h-2*gap)/2
+        small_ap = RectangleAperture(p, q, unit=unit)
+
+        s = min(w, h) / 2 / math.sqrt(2)
+        large_ap = RectangleAperture(s, s, rotation=math.pi/4, unit=unit)
+        large_ap_neg = RectangleAperture(s+2*gap, s+2*gap, rotation=math.pi/4, unit=unit)
+
+        a = gap/2 + p/2
+        b = gap/2 + q/2
+
+        self.top_copper.append(Flash(-a, -b, aperture=small_ap, unit=unit))
+        self.top_copper.append(Flash(-a,  b, aperture=small_ap, unit=unit))
+        self.top_copper.append(Flash( a, -b, aperture=small_ap, unit=unit))
+        self.top_copper.append(Flash( a,  b, aperture=small_ap, unit=unit))
+        self.top_copper.append(Flash(0, 0, aperture=large_ap_neg, polarity_dark=False, unit=unit))
+        self.top_copper.append(Flash(0, 0, aperture=large_ap, unit=unit))
+        self.top_mask = self.top_copper
+
+
+class PoweredProto(ObjectGroup):
+    def __init__(self, pitch=None, drill=None, clearance=None, power_pad_dia=None, via_size=None, trace_width=None, unit=MM):
+        super().__init__(0, 0)
+        self.unit = unit
+        self.pitch = pitch = pitch or unit(2.54, MM)
+        self.drill = drill = drill or unit(0.9, MM)
+        self.clearance = clearance = clearance or unit(0.3, MM)
+        self.trace_width = trace_width = trace_width or unit(0.3, MM)
+        self.via_size = via_size = via_size or unit(0.4, MM)
+
+        main_pad_dia = pitch - trace_width - 2*clearance
+        power_pad_dia_max = math.sqrt(2)*pitch - main_pad_dia - 2*clearance
+        if power_pad_dia is None:
+            power_pad_dia = power_pad_dia_max - clearance # reduce some more to give the user more room
+        elif power_pad_dia > power_pad_dia_max:
+            warnings.warn(f'Power pad diameter {power_pad_dia} > {power_pad_dia_max} violates pad-to-pad clearance')
+        self.power_pad_dia = power_pad_dia
+
+        main_ap = CircleAperture(main_pad_dia, unit=unit)
+        power_ap = CircleAperture(self.power_pad_dia, unit=unit)
+
+        for l in [self.top_copper, self.bottom_copper]:
+            l.append(Flash(0, 0, aperture=main_ap, unit=unit))
+
+            l.append(Flash(-pitch/2, -pitch/2, aperture=power_ap, unit=unit))
+            l.append(Flash(-pitch/2,  pitch/2, aperture=power_ap, unit=unit))
+            l.append(Flash( pitch/2, -pitch/2, aperture=power_ap, unit=unit))
+            l.append(Flash( pitch/2,  pitch/2, aperture=power_ap, unit=unit))
+
+        self.drill_pth.append(Flash(0, 0, ExcellonTool(drill, plated=True, unit=unit), unit=unit))
+        self.drill_pth.append(Flash(-pitch/2, -pitch/2, ExcellonTool(via_size, plated=True, unit=unit), unit=unit))
+
+        self.top_mask = copy(self.top_copper)
+        self.bottom_mask = copy(self.bottom_copper)
+
+        self.line_ap = CircleAperture(trace_width, unit=unit)
+        self.top_copper.append(Line(-pitch/2, -pitch/2, -pitch/2, pitch/2, aperture=self.line_ap, unit=unit))
+        self.top_copper.append(Line(pitch/2, -pitch/2, pitch/2, pitch/2, aperture=self.line_ap, unit=unit))
+        self.bottom_copper.append(Line(-pitch/2, -pitch/2, pitch/2, -pitch/2, aperture=self.line_ap, unit=unit))
+        self.bottom_copper.append(Line(-pitch/2, pitch/2, pitch/2, pitch/2, aperture=self.line_ap, unit=unit))
+
+    def inst(self, x, y):
+        inst = copy(self)
+        if (x + y) % 2 == 0:
+            inst.drill_pth = inst.drill_pth[:-1]
+
+        c = self.power_pad_dia/2 + self.clearance
+        p = self.pitch/2
+
+        if x == 1:
+            inst.top_silk = [Line(-p, -p+c, -p, p-c, aperture=self.line_ap, unit=self.unit)]
+        elif x % 2 == 0:
+            inst.top_silk = [Line(p, -p+c, p, p-c, aperture=self.line_ap, unit=self.unit)]
+
+        if y == 0:
+            inst.bottom_silk = [Line(-p+c, -p, p-c, -p, aperture=self.line_ap, unit=self.unit)]
+        elif y % 2 == 1:
+            inst.bottom_silk = [Line(-p+c, p, p-c, p, aperture=self.line_ap, unit=self.unit)]
+
+        return inst
+
+    def bounding_box(self, unit=MM):
+        x, y, rotation = self.abs_pos
+        p = self.pitch/2
+        return unit.convert_bounds_from(self.unit, ((x-p, y-p), (x+p, y+p)))
+
+
+def convert_to_mm(value, unit):
+    unitl  = unit.lower()
+    if unitl == 'mm':
+        return value
+    elif unitl == 'cm':
+        return value*10
+    elif unitl == 'in':
+        return value*25.4
+    elif unitl == 'mil':
+        return value/1000*25.4
+    else:
+        raise ValueError(f'Invalid unit {unit}, allowed units are mm, cm, in, and mil.')
+
+
+_VALUE_RE = re.compile('([0-9]*\.?[0-9]+)(cm|mm|in|mil|%)')
+def eval_value(value, total_length=None):
+    if not isinstance(value, str):
+        return None
+
+    m = _VALUE_RE.match(value.lower())
+    number, unit = m.groups()
+    if unit == '%':
+        if total_length is None:
+            raise ValueError('Percentages are not allowed for this value')
+        return total_length * float(number) / 100
+    return convert_to_mm(float(number), unit)
+
+
+def _demo():
+    #pattern1 = PatternProtoArea(2.54, obj=THTPad.circle(0, 0, 0.9, 1.8, paste=False))
+    #pattern2 = PatternProtoArea(1.2, 2.0, obj=SMDPad.rect(0, 0, 1.0, 1.8, paste=False))
+    #pattern3 = PatternProtoArea(2.54, 1.27, obj=SMDPad.rect(0, 0, 2.3, 1.0, paste=False))
+    #stack = TwoSideLayout(pattern2, pattern3)
+    #layout = PropLayout([pattern1, stack], 'h', [0.5, 0.5])
+    #pattern = PatternProtoArea(2.54, obj=ManhattanPads(2.54))
+    pattern = PatternProtoArea(2.54, obj=PoweredProto())
+    pb = ProtoBoard(100, 80, pattern, mounting_hole_dia=3.2, mounting_hole_offset=5)
+    print(pb.pretty_svg())
+    pb.layer_stack().save_to_directory('/tmp/testdir')
+
+
+if __name__ == '__main__':
+    _demo()