AI Flow

@@ -4,7 +4,7 @@ version = 4  [[package]] name = "adom-aiflow"-version = "0.1.53"+version = "0.1.54" dependencies = [  "aiflow-analyze",  "aiflow-board",@@ -24,7 +24,7 @@ dependencies = [  [[package]] name = "aiflow-analyze"-version = "0.1.53"+version = "0.1.54" dependencies = [  "serde",  "serde_json",@@ -33,7 +33,7 @@ dependencies = [  [[package]] name = "aiflow-board"-version = "0.1.53"+version = "0.1.54" dependencies = [  "roxmltree",  "serde",@@ -42,7 +42,7 @@ dependencies = [  [[package]] name = "aiflow-bridge"-version = "0.1.53"+version = "0.1.54" dependencies = [  "aiflow-board",  "serde",@@ -51,7 +51,7 @@ dependencies = [  [[package]] name = "aiflow-copper"-version = "0.1.53"+version = "0.1.54" dependencies = [  "aiflow-board",  "aiflow-grid",@@ -61,7 +61,7 @@ dependencies = [  [[package]] name = "aiflow-grid"-version = "0.1.53"+version = "0.1.54" dependencies = [  "aiflow-board",  "serde",@@ -70,7 +70,7 @@ dependencies = [  [[package]] name = "aiflow-place"-version = "0.1.53"+version = "0.1.54" dependencies = [  "aiflow-board",  "serde",@@ -79,7 +79,7 @@ dependencies = [  [[package]] name = "aiflow-pours"-version = "0.1.53"+version = "0.1.54" dependencies = [  "aiflow-board",  "aiflow-copper",@@ -89,7 +89,7 @@ dependencies = [  [[package]] name = "aiflow-router"-version = "0.1.53"+version = "0.1.54" dependencies = [  "aiflow-board",  "aiflow-grid",@@ -99,7 +99,7 @@ dependencies = [  [[package]] name = "aiflow-run"-version = "0.1.53"+version = "0.1.54" dependencies = [  "serde",  "serde_json",

@@ -213,6 +213,154 @@ def symbol_choice(comp, fp_text, sym_path):     return 'own'  +# -------------------------------------------------------------- 3D model orientation+# A STEP model is often authored Y-up (the convention of many mechanical tools and every glTF), and+# nothing in the file says which axis is up. Bound as published, a Y-up part lies on its side on the+# board: the electrolytic can on its flank, the inductor on edge. So every model is checked against its+# own footprint before it is bound: the two axes that lie on the board must span the footprint, and the+# one left over is the height. A model whose height is not on Z is turned upright and re-seated at z=0.++_NUM = r'[-+0-9.Ee]+'++def step_extents(text):+    pts = [tuple(map(float, m)) for m in re.findall(r"CARTESIAN_POINT\s*\(\s*'[^']*'\s*,\s*\(\s*(%s)\s*,\s*(%s)\s*,\s*(%s)\s*\)" % (_NUM, _NUM, _NUM), text)]+    if not pts: return None+    return [min(p[i] for p in pts) for i in range(3)], [max(p[i] for p in pts) for i in range(3)]++def _blocks(text, head):+    """Every balanced (head ...) s-expression in text."""+    out, i = [], 0+    while True:+        i = text.find('(' + head, i)+        if i < 0: return out+        depth, j = 0, i+        while j < len(text):+            depth += (text[j] == '(') - (text[j] == ')')+            if depth == 0: break+            j += 1+        out.append(text[i:j + 1]); i = j + 1++def footprint_span(text):+    """The part's room on the board, in mm: its courtyard (leads included), else its fab drawing, else its pads."""+    def outline(layer):+        pts = []+        for head in ('fp_line', 'fp_rect', 'fp_poly', 'fp_arc'):+            for blk in _blocks(text, head + ' ') + _blocks(text, head + '\n') + _blocks(text, head + '\t') + _blocks(text, head + '\r'):+                if '"%s"' % layer not in blk: continue+                pts += [(float(x), float(y)) for x, y in re.findall(r'\((?:start|end|mid|xy)\s+(%s)\s+(%s)\)' % (_NUM, _NUM), blk)]+        for blk in _blocks(text, 'fp_circle'):+            if '"%s"' % layer not in blk: continue+            c = re.search(r'\(center\s+(%s)\s+(%s)\)' % (_NUM, _NUM), blk); e = re.search(r'\(end\s+(%s)\s+(%s)\)' % (_NUM, _NUM), blk)+            if c and e:+                cx, cy = float(c.group(1)), float(c.group(2)); r = math.hypot(float(e.group(1)) - cx, float(e.group(2)) - cy)+                pts += [(cx - r, cy - r), (cx + r, cy + r)]+        return pts+    pts = outline('F.CrtYd') or outline('F.Fab')+    if not pts:+        for blk in _blocks(text, 'pad '):+            a = re.search(r'\(at\s+(%s)\s+(%s)' % (_NUM, _NUM), blk); sz = re.search(r'\(size\s+(%s)\s+(%s)\)' % (_NUM, _NUM), blk)+            if a and sz:+                x, y, w, h = float(a.group(1)), float(a.group(2)), float(sz.group(1)), float(sz.group(2))+                pts += [(x - w / 2, y - h / 2), (x + w / 2, y + h / 2)]+    if not pts: return None+    xs, ys = [q[0] for q in pts], [q[1] for q in pts]+    return max(xs) - min(xs), max(ys) - min(ys)++def up_axis(ext, span):+    """Which model axis is the height: the one whose removal leaves the two that best match the footprint.+    Returns (up, misfit of that choice, misfit with Z as the height, extents)."""+    mn, mx = ext; d = [mx[i] - mn[i] for i in range(3)]+    fw, fh = sorted(span)+    def miss(up):+        a, b = sorted(d[i] for i in range(3) if i != up)+        return abs(a - fw) / max(fw, 0.1) + abs(b - fh) / max(fh, 0.1)+    best = min((2, 1, 0), key=miss)+    # Z stays the height unless another axis fits the footprint decisively better+    if best != 2 and not (miss(2) > 0.35 and miss(best) < 0.5 * miss(2)): best = 2+    return best, miss(best), miss(2), d++def _rot(up):+    # rotation that carries the model's up axis onto +Z (right-handed, determinant +1)+    if up == 1: return lambda x, y, z: (x, -z, y)    # +90 about X: +Y -> +Z+    if up == 0: return lambda x, y, z: (-z, y, x)    # -90 about Y: +X -> +Z+    return lambda x, y, z: (x, y, z)++def make_upright(text, up):+    """Rotate every point and direction so `up` becomes Z, then seat the model on z=0. A rigid motion of+    all CARTESIAN_POINTs and DIRECTIONs moves STEP B-rep geometry consistently (radii and lengths keep)."""+    R = _rot(up)+    def sub(kind, shift):+        def f(m):+            x, y, z = R(float(m.group(2)), float(m.group(3)), float(m.group(4)))+            if shift: z -= shift+            return "%s('%s',(%.9g,%.9g,%.9g))" % (kind, m.group(1), x, y, z)+        return f+    pat = lambda kind: r"%s\s*\(\s*'([^']*)'\s*,\s*\(\s*(%s)\s*,\s*(%s)\s*,\s*(%s)\s*\)\s*\)" % (kind, _NUM, _NUM, _NUM)+    t = re.sub(pat('DIRECTION'), sub('DIRECTION', 0), text)+    t = re.sub(pat('CARTESIAN_POINT'), sub('CARTESIAN_POINT', 0), t)+    zmin = step_extents(t)[0][2]+    t = re.sub(pat('CARTESIAN_POINT'), sub('CARTESIAN_POINT', 0) if abs(zmin) < 1e-6 else (lambda m: "CARTESIAN_POINT('%s',(%.9g,%.9g,%.9g))" % (m.group(1), float(m.group(2)), float(m.group(3)), float(m.group(4)) - zmin)), t)+    return t++def kicad_model_transform(fp_text):+    """The footprint's own (model ...) entry: rotate (deg) and offset (mm), or None. KiCad applies these+    when it shows the model; a Fusion package gets the raw STEP, so they must be applied here."""+    i = fp_text.find('(model')+    if i < 0: return None+    blk = fp_text[i:i + 600]+    rot = re.search(r'\(rotate\s*\(xyz\s+(%s)\s+(%s)\s+(%s)\s*\)' % (_NUM, _NUM, _NUM), blk)+    off = re.search(r'\(offset\s*\(xyz\s+(%s)\s+(%s)\s+(%s)\s*\)' % (_NUM, _NUM, _NUM), blk)+    return [float(v) for v in rot.groups()] if rot else [0.0, 0.0, 0.0], [float(v) for v in off.groups()] if off else [0.0, 0.0, 0.0]++def _matrix(rx, ry, rz):+    # KiCad: p' = Rz(-rz) . Ry(-ry) . Rx(-rx) . p (angles in degrees, applied X first)+    def R(axis, deg):+        c, s_ = math.cos(math.radians(-deg)), math.sin(math.radians(-deg))+        return {'x': [[1, 0, 0], [0, c, -s_], [0, s_, c]], 'y': [[c, 0, s_], [0, 1, 0], [-s_, 0, c]], 'z': [[c, -s_, 0], [s_, c, 0], [0, 0, 1]]}[axis]+    mul = lambda A, B: [[sum(A[i][k] * B[k][j] for k in range(3)) for j in range(3)] for i in range(3)]+    return mul(R('z', rz), mul(R('y', ry), R('x', rx)))++def transform_step(text, M, off=(0, 0, 0)):+    """Apply a rigid motion to every CARTESIAN_POINT and DIRECTION (B-rep geometry moves with them)."""+    ap = lambda v: [sum(M[i][k] * v[k] for k in range(3)) for i in range(3)]+    pat = lambda kind: r"%s\s*\(\s*'([^']*)'\s*,\s*\(\s*(%s)\s*,\s*(%s)\s*,\s*(%s)\s*\)\s*\)" % (kind, _NUM, _NUM, _NUM)+    def sub(kind, add):+        def f(m):+            v = ap([float(m.group(2)), float(m.group(3)), float(m.group(4))])+            return "%s('%s',(%.9g,%.9g,%.9g))" % (kind, m.group(1), v[0] + add[0], v[1] + add[1], v[2] + add[2])+        return f+    t = re.sub(pat('DIRECTION'), sub('DIRECTION', (0, 0, 0)), text)+    return re.sub(pat('CARTESIAN_POINT'), sub('CARTESIAN_POINT', off), t)++def upright_model(step, fp, out_dir):+    """The model as it must sit on the board: the footprint's own transform applied, then checked against+    the footprint (the two board-plane extents must span it). Returns (path, note); note is None when the+    STEP was already right."""+    text = step.read_text(errors='ignore'); fpt = fp.read_text(errors='ignore')+    notes = []+    tr = kicad_model_transform(fpt)+    if tr and (any(abs(a) > 1e-9 for a in tr[0]) or any(abs(o) > 1e-9 for o in tr[1])):+        text = transform_step(text, _matrix(*tr[0]), tr[1])+        notes.append("the footprint's own model transform (rotate %s, offset %s mm) applied, as KiCad does" % (' '.join('%g' % a for a in tr[0]), ' '.join('%g' % o for o in tr[1])))+    ext = step_extents(text); span = footprint_span(fpt)+    if ext and span:+        up, miss, miss_z, d = up_axis(ext, span)+        if up != 2:+            what = 'its height is on %s, not Z (extents %s mm against a %.1f x %.1f mm courtyard)' % ('XYZ'[up], ' x '.join('%.2f' % x for x in d), span[0], span[1])+            if notes:  # the footprint gave a transform and the result still lies wrong: say so, do not guess twice+                notes.append(what + ': CHECK this part in 3D; its footprint\'s (model ... (rotate ...)) entry may be wrong')+            else:+                text = make_upright(text, up)+                notes.append(what + ': turned upright and seated on the board')+    if not notes: return step, None+    out_dir.mkdir(parents=True, exist_ok=True)+    out = out_dir / (step.stem + '-zup.step'); out.write_text(text)+    return out, '; '.join(notes)+++ORIENT_RULES = 1  # bump when the orientation rules change: parts bound under older rules are bound again++ def silk_text(t):     """Board text a small board can carry: each package's >NAME at 0.8 mm (thick enough for a fab's     0.15 mm line), and its >VALUE on tDocu (51), drawn in the editor but never printed. Fusion copies@@ -259,7 +407,7 @@ def cmd_library(a):     if not want: err('no parts: give --parts parts.json ([{mpn, page?, footprint?}]) or a BOM .csv with an mpn column')     cache = json.loads(Path(a.numbers).read_text()) if a.numbers else {}     lib_dir = STATE / 'library'; (lib_dir / 'parts').mkdir(parents=True, exist_ok=True)-    added, kept, unverified = [], [], {}+    added, kept, unverified, turned = [], [], {}, {}     seen = set()     for w in want:         mpn = w['mpn']@@ -300,7 +448,13 @@ def cmd_library(a):         missing = [k for k in ('mouser', 'digikey', 'lcsc') if not numbers.get(k)]         stock = (meta['component'].get('manufacturer') or '').strip().lower() == 'adom'         if missing and not stock: unverified[mpn] = missing + (['(' + '; '.join(sorted(set(notes))) + ')'] if notes else [])-        st['parts'][mpn] = {**st['parts'].get(mpn, {}), 'lbr': str(out_lbr), 'step': str(step) if step else None, 'numbers': numbers, 'symbol': choice}+        onote = None+        if step:+            step, onote = upright_model(step, fp, STATE / 'models')+            if onote: turned[mpn] = onote+        prev = st['parts'].get(mpn, {})+        if prev.get('urn') and prev.get('orient') != ORIENT_RULES: prev = {k: v for k, v in prev.items() if k != 'urn'}  # bound before the check: bind again+        st['parts'][mpn] = {**prev, 'lbr': str(out_lbr), 'step': str(step) if step else None, 'numbers': numbers, 'symbol': choice, 'orient': ORIENT_RULES, 'orientNote': onote}         added.append(mpn)         say('part %s: %s symbol, model %s, %s' % (mpn, choice, step.name if step else 'none', 'Adom stock' if stock else 'Mouser %s, DigiKey %s, LCSC %s' % (numbers.get('mouser', '-'), numbers.get('digikey', '-'), numbers.get('lcsc', '-'))))     save_state(st)@@ -351,6 +505,11 @@ def cmd_library(a):     ok('library %s: %d part(s) (%d added, %d kept), %d with real 3D, one library at %s' % (name, len(st['parts']), len(added), len(kept), len(urns), st['libraryPath']),        ['No distributor number yet: ' + '; '.join('%s %s' % (m, ' '.join(v)) for m, v in unverified.items()) + '. Run `fusion library` again when the services are back, or add the numbers to the part\'s wiki page (component.distributor_links).' if unverified else '',         '3D not bound yet: %s; run this again to retry them' % ', '.join(unbound) if unbound else '',+        ('3D turned upright before binding: ' + '; '.join('%s (%s)' % (m, n) for m, n in turned.items()) + '.') if turned else '',+        'Check the 3D yourself before going on: a model can be authored Y-up while Fusion and the board are Z-up, and a part bound that way lies on its side (an electrolytic can on its flank, an inductor on edge). '+        'This step already applied each footprint\'s own model transform and checked every model against its footprint, but look anyway: once the board exists, '+        '`fusion_show_3d_board` then `fusion_take_screenshot` (Windows window capture cannot see Fusion\'s 3D viewport), and every part must sit flat on its pads the way its datasheet drawing shows. '+        'A part that does not: say which, and fix its model or its footprint\'s (model ... (rotate ...)) entry, then run `fusion library` again.',         'Next: adom-aiflow fusion schematic --netlist <netlist.json> (the design starts from this library). New parts later: run `fusion library` again with them; they join this same library.'])  @@ -473,11 +632,19 @@ def cmd_schematic(a):     src = ab('fusion_board_source', {'expectDocument': name})     if not src.get('source'): err('could not read the board back: %s' % src.get('error'))     out = Path(a.board_out); out.write_text(src['source'])+    # 3D on the board: a part added live can arrive without the library's 3D binding (Fusion then draws+    # a flat placeholder box in the 3D PCB). Count them so the AI looks instead of assuming.+    want3d = {m for m, p_ in st['parts'].items() if p_.get('urn')}+    no3d = sorted(re.search(r'name="([^"]+)"', e).group(1) for e in re.findall(r'<element [^>]*>', src['source'])+                  if (re.search(r'package="([^"]+)"', e) or [None, None])[1] in want3d and 'package3d_urn' not in e)     dru = Path(a.fixed).parent / 'board.kicad_dru' if a.fixed else None     if dru and dru.is_file(): shutil.copy(dru, out.with_suffix('.kicad_dru'))     st['design'] = name; save_state(st)     ok('schematic drawn live in %d group(s), every pin on its net; the board followed with %d parts; saved as %s; board written to %s' % (len(plan['groups']), n, name, out),-       ['Next: adom-aiflow start --board %s --spec <spec.json> --target %s --remote-board fusion:%s --engine <you> --prompt-time <paste time>' % (out, TARGET or '<box>', name)])+       [('3D: %d part(s) on the board carry no 3D binding and show as flat placeholder boxes in the 3D PCB: %s. The library has their models; '+         'Fusion dropped the binding when the part was added. Write each package\'s package3d_urn onto its board element and schematic part '+         '(fusion_export_eagle_source both, add the attribute, import as the design) before calling the board done, and confirm in 3D with fusion_take_screenshot.' % (len(no3d), ', '.join(no3d))) if no3d else '',+        'Next: adom-aiflow start --board %s --spec <spec.json> --target %s --remote-board fusion:%s --engine <you> --prompt-time <paste time>' % (out, TARGET or '<box>', name)])   # ---------------------------------------------------------------- export