QFP58

#!/usr/bin/env python3
"""Derive per-layer copper/outline geometry from qfp_geom primitives; write KiCad-importable SVGs + preview."""
import os, sys, math
import numpy as np
from shapely.geometry import Point, LineString, Polygon, box
from shapely.ops import unary_union, split
from shapely import affinity
from qfp_geom import P, build, arc_points, u


def prim_shape(p):
    pts = [tuple(p['p0']), tuple(p['p1'])] if p['kind'] == 'seg' else [tuple(q) for q in arc_points(p)]
    return LineString(pts).buffer(p['w']/2, cap_style=1, join_style=1, quad_segs=16)

def rect(c, along, across, ang):
    r = box(-along/2, -across/2, along/2, across/2)
    return affinity.translate(affinity.rotate(r, ang, use_radians=True, origin=(0, 0)), *c)

def disk(c, dia): return Point(*c).buffer(dia/2, quad_segs=64)

def outline_feed(f):
    circ = Point(0, 0).buffer(P['board_d']/2, quad_segs=180)
    uu, tt, e = f['sma']['u'], f['sma']['t'], f['sma']['edge']
    half = Polygon([tuple(e + 100*tt), tuple(e - 100*tt), tuple(e - 100*tt - 100*uu), tuple(e + 100*tt - 100*uu)])
    return circ.intersection(half)

def feed_layers(f):
    d = P['res_pitch']/2
    s = f['sma']
    ang_u = math.atan2(s['u'][1], s['u'][0])
    res_pads = [rect(c + k*d*u(a), P['res_pad'][0], P['res_pad'][1], a) for _, c, a, _ in f['res'] for k in (-1, 1)]
    sig = rect(s['sig_c'], P['sma_sig_len'], f['prims'][-1]['w'], ang_u)
    gnd = [rect(g, P['sma_gnd_len'], P['sma_gnd_w'], ang_u) for g in s['gnd_c']]
    pinpads = [disk(p, P['pin_pad']) for p in f['pins']]
    viapads = [disk(v, P['via_pad']) for v in f['vias']]
    net = unary_union([prim_shape(p) for p in f['prims']] + res_pads + [sig] + pinpads)
    outline = outline_feed(f)
    plane = outline.buffer(-P['edge_pullback'])
    for p in f['pins']: plane = plane.difference(disk(p, P['gnd_antipad']))
    for p in f['mh']: plane = plane.difference(disk(p, P['mh_clear']))
    B = unary_union([net] + gnd + viapads)
    F = unary_union([plane] + gnd + pinpads)
    drills = [(tuple(p), P['pin_drill'], True) for p in f['pins']] + [(v, P['via_drill'], True) for v in f['vias']] \
           + [(tuple(p), P['mh_drill'], False) for p in f['mh']]
    return dict(B_Cu=B, F_Cu=F, Edge_Cuts=outline, drills=drills, net=net)

def patch_layers():
    pins = [P['rp']*u(k*math.pi/2) for k in range(4)]
    patch = disk((0, 0), P['patch_d'])
    for p in pins: patch = patch.difference(disk(p, P['patch_antipad']))
    rings = [disk(p, P['patch_pin_ring']) for p in pins]
    B = unary_union([patch] + rings)
    F = unary_union([disk(p, P['disk_d']) for p in pins])
    outline = Point(0, 0).buffer(P['patch_d']/2 + P['patch_margin'], quad_segs=180)
    return dict(B_Cu=B, F_Cu=F, Edge_Cuts=outline, drills=[(tuple(p), P['pin_drill'], True) for p in pins])


# ----------------------------------------------------------------------------- SVG (hole-free pieces)
def polys_of(g):
    if g.is_empty: return []
    if isinstance(g, Polygon): return [g]
    return [p for p in getattr(g, 'geoms', []) if isinstance(p, Polygon)]

def fracture(g):
    out, todo = [], polys_of(g)
    while todo:
        p = todo.pop()
        if not p.interiors:
            out.append(p); continue
        cy = Polygon(p.interiors[0]).centroid.y + 1e-4
        x0, _, x1, _ = p.bounds
        todo += [q for q in split(p, LineString([(x0 - 1, cy), (x1 + 1, cy)])).geoms if q.area > 1e-6]
    return out

def svg(path, geom, frame, outline=False, color='#000000'):
    x0, y0, W, H = frame
    pth = lambda p: 'M' + ' L'.join(f'{x:.4f},{-y:.4f}' for x, y in p.exterior.coords) + ' Z'
    if outline:
        body = [f'<path d="{pth(p)}" fill="none" stroke="{color}" stroke-width="0.1"/>' for p in polys_of(geom)]
    else:
        body = [f'<path d="{pth(p)}" fill="{color}" stroke="none"/>' for p in fracture(geom)]
    open(path, 'w').write(f'<svg xmlns="http://www.w3.org/2000/svg" width="{W}mm" height="{H}mm" '
                          f'viewBox="{x0} {y0} {W} {H}">\n' + '\n'.join(body) + '\n</svg>\n')


# ----------------------------------------------------------------------------- preview
def preview(path, hand='RHCP'):
    import matplotlib; matplotlib.use('Agg')
    import matplotlib.pyplot as plt
    from matplotlib.patches import Polygon as MP, Circle
    f, info = build(hand)
    FL, PL = feed_layers(f), patch_layers()
    def draw(ax, g, **kw):
        for p in fracture(g): ax.add_patch(MP(list(p.exterior.coords), closed=True, **kw))
    fig, axs = plt.subplots(1, 2, figsize=(15, 7.5), gridspec_kw=dict(width_ratios=[1.35, 1]))
    ax = axs[0]
    draw(ax, FL['F_Cu'], fc='#dcdcdc', ec='none')
    draw(ax, FL['B_Cu'], fc='#b87333', ec='none')
    for (x, y), dd, pl in FL['drills']: ax.add_patch(Circle((x, y), dd/2, fc='k' if pl else 'w', ec='k', lw=0.5))
    for p in polys_of(FL['Edge_Cuts']):
        xs, ys = zip(*p.exterior.coords); ax.plot(xs, ys, 'k', lw=0.8)
    for ref, c, a, v in f['res']:
        ax.annotate(f'{ref} {v}Ω', c, xytext=(c[0]*1.18, c[1]*1.18), fontsize=8, color='#a00000',
                    ha='center', arrowprops=dict(arrowstyle='-', color='#a00000', lw=0.6))
    ph = {0: '0°', 1: '−90°', 2: '−180°', 3: '−270°'}
    for k, p in enumerate(f['pins']):
        ax.text(*(p*0.42), ph[k], fontsize=7, ha='center', va='center', color='#0040a0')
    ax.text(*(f['sma']['edge']*0.93 + f['sma']['t']*5), 'J1 SMA', fontsize=8, ha='center')
    ax.set_aspect('equal'); ax.set_xlim(-31, 31); ax.set_ylim(-31, 31); ax.grid(alpha=.25)
    ax.set_title(f'Feed board {hand} — top view: B.Cu network (copper) over F.Cu ground (grey)', fontsize=10)
    ax = axs[1]
    draw(ax, PL['B_Cu'], fc='#b87333', ec='none', alpha=.55)
    draw(ax, PL['F_Cu'], fc='#2060c0', ec='none', alpha=.8)
    for (x, y), dd, _ in PL['drills']: ax.add_patch(Circle((x, y), dd/2, fc='k'))
    for p in polys_of(PL['Edge_Cuts']):
        xs, ys = zip(*p.exterior.coords); ax.plot(xs, ys, 'k', lw=0.8)
    ax.set_aspect('equal'); ax.set_xlim(-13, 13); ax.set_ylim(-13, 13); ax.grid(alpha=.25)
    ax.set_title('Patch board — top view: B.Cu patch (faces ground), F.Cu coupling disks (blue)', fontsize=10)
    plt.tight_layout(); plt.savefig(path, dpi=120); plt.close(fig)


def write_svgs(outdir):
    os.makedirs(outdir, exist_ok=True)
    for hand in ('RHCP', 'LHCP'):
        f, _ = build(hand)
        L = feed_layers(f)
        b = f'QFP58-feed-{hand}'
        fr = (-32, -32, 64, 64)
        svg(f'{outdir}/{b}-B_Cu.svg', L['B_Cu'], fr)
        svg(f'{outdir}/{b}-F_Cu.svg', L['F_Cu'], fr)
        svg(f'{outdir}/{b}-Edge_Cuts.svg', L['Edge_Cuts'], fr, outline=True)
    L = patch_layers()
    fr = (-14, -14, 28, 28)
    svg(f'{outdir}/QFP58-patch-B_Cu.svg', L['B_Cu'], fr)
    svg(f'{outdir}/QFP58-patch-F_Cu.svg', L['F_Cu'], fr)
    svg(f'{outdir}/QFP58-patch-Edge_Cuts.svg', L['Edge_Cuts'], fr, outline=True)


if __name__ == '__main__':
    hand = sys.argv[1] if len(sys.argv) > 1 else 'RHCP'
    preview(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'docs', f'preview_{hand}.png'), hand)