Media-to-Fusion

Skill: Medien (Bild/Video/Referenzpaket) zu Fusion 360 Rekonstruktion

Wenn der Benutzer ein Foto, einen Multi-Winkel-Referenzordner oder ein Video (.mp4, .mov, .png, .jpg, .webp) bereitstellt und darum bittet, das Objekt in Autodesk Fusion 360 nachzubilden, folge diesem 6-Phasen deterministischen Ingenieur-Workflow.

STRENGES CAD-MANDAT:

• Springe niemals direkt zum Schreiben von Fusion MCP Extrusionen, ohne vorher process_media.py ausgeführt, einen realen Millimeter-Maßstab etabliert und eine kinematische Stückliste (BOM) erstellt zu haben.
• Jede Komponente muss mit nativen Skizzen, Konstruktionsebenen, Skizzenlinien/Bögen/Kreisen, Benutzerparametern und Extrudieren/Verrunden/Verbinden-Features in der Fusion 360 Timeline rekonstruiert werden. Erzeuge niemals rohe Mesh-Körper (root.meshBodies.add).

---

Phase 0: Pre-Flight Sicherheitsgate & Monorepo-Umgebung (Obligatorisch)

Bevor CAD-Geometrie in Fusion 360 erstellt wird, richte den Arbeitsbereich ein und überprüfe die Live-MCP-Konnektivität:

1. CAD Monorepo-Ausrichtung:

   • Primärer Arbeitsbereich: Aktives CAD-Monorepo oder Projektstamm (z. B. CAD_MONOREPO_ROOT oder aktueller Arbeitsbereich).
   • Strikte Isolationsgarantie: Erstelle niemals temporäre Dateien, Skripte oder Renderings im Repository-Stammverzeichnis und mutiere shared/ nicht.
   • Speichere neue Modelle unter models/<NN>_<Modellname>/ (z. B. models/02_Modularer_Schreibtischorganizer/). Wenn ein neues Modell begonnen wird, verwende scaffold_text_model.py "<Modellname>".
   • Importiere universelle CAD-Hilfsmittel aus shared/ (fusion_client, cad_primitives, hardware_library, scene_animator).
   • Lese Domänenreferenzspeicher, bevor Skripte geschrieben werden:
     • references/kinematic-archetypes.md (verifizierte Mechanikgleichungen)
     • references/fdm-hardware-tolerances.md (Drucktoleranzen & Befestigungssenkungen)
     • references/fusion-api-gotchas.md (Hochgeschwindigkeitsanimation & API-Fixes)

2. Canary Probe: Rufe das fusion-mcp-Tool execute_api_script auf mit:

   def run(context):
       import adsk.core, adsk.fusion
       app = adsk.core.Application.get()
       if not app:
           raise RuntimeError("Instanz der Autodesk Fusion 360 Anwendung nicht gefunden.")
       design = adsk.fusion.Design.cast(app.activeProduct)
       if not design:
           raise RuntimeError("Kein aktives Fusion 360 Konstruktionsdokument geöffnet.")
       print("FUSION_MCP_READY")
   

3. Fail-Fast-Regel:

   • Du kannst Phase 1–3 (Medien-Metrologie) ausführen, während Fusion 360 geschlossen ist, aber wenn FUSION_MCP_READY vor Phase 4 fehlschlägt, STOPPE vor dem Senden von CAD-Bauskripten und weise den Benutzer an, Fusion 360 mit einem aktiven Konstruktionsdokument zu öffnen.

---

Phase 1: Medienaufnahme & Keyframe-/Konturextraktion

[!IMPORTANT] Workspace-Isolationsregel: Gib Medienverarbeitungsdateien niemals in das Haupt-Repository-Stammverzeichnis aus (z. B. ist ./media_workspace verboten). Stelle immer sicher, dass ein dedizierter Modellordner unter models/<NN>_<Modellname>/ existiert, und leite die gesamte Medienverarbeitung in models/<NN>_<Modellname>/workspace/media um.

1. Führe die Vorverarbeitungs- und Metrologie-Engine auf dem Eingabebild, -video oder -verzeichnis im isolierten Workspace des Modells aus:

   python3 <pfad_zu_skills>/media-to-fusion/scripts/process_media.py "<eingabe_media_oder_ordnerpfad>" --out-dir models/<NN>_<Modellname>/workspace/media
   

2. Untersuche models/<NN>_<Modellname>/workspace/media/media_manifest.json und betrachte die generierten visuellen Artefakte mit read_file:
   • Für Referenzordner: Betrachte zuerst dataset_overview.png, dann inspiziere einzelne Unterarbeitsbereiche (models/<NN>_<Modellname>/workspace/media/<slug>/).
   • Für Videos: Betrachte contact_sheet.png und einzelne keyframe_XX_grid.png Dateien (automatisch gefiltert, um schwarze Einblendungen, Bewegungsunschärfe und Handverwischungen zu verwerfen, während kollabierte, mittlere und ausgefahrene kinematische Zustände erfasst werden).
   • Für Bilder: Betrachte annotated_grid.png (Dual-Kontrast 100px Haupt-/50px Neben-Pixel-Linealraster) und contours_preview.png (erkannte Canny-Konturen + Schlitze/Loch-Zentroide und mittlere Pixel-Pitch in derselben Zeile).
   • Split-Screen-Prüfung: Überprüfe viewport_layout.is_split in media_manifest.json (z. B. nebeneinanderliegende Front- und Rechts-orthografische Ansichten in einem einzelnen Bild), damit Pixelabstände innerhalb jedes Unter-Viewports unabhängig gemessen werden.

---

Phase 2: Mehrstufige Skalenkalibrierung (Finden des "Goldenen Datums")

Bevor mit dem Modellieren begonnen wird, etabliere den realen Millimeter-Maßstab (mm_per_px) mit dieser strengen Prioritätshierarchie:

1. Priorität 1 — Explizite Bemaßungshinweise oder Bauplatteneinschränkungen im Medium:
   • Überprüfe Referenzbilder auf Bemaßungspfeile (z. B. Gesamtbreite 35 cm / 350 mm, Höhe 63 cm / 630 mm, Tiefe 32 cm / 320 mm, oder innenliegende Einsatzwanne-Bemaßungen wie 330 x 100 x 70 mm).
   • Überprüfe auf 3D-Drucker-Bauplattenhinweise (z. B. "FÜR 220 x 220 mm DRUCKER" $\rightarrow$ maximale Einzelteilbreite/-länge ist typischerweise 200–210 mm).
2. Priorität 2 — Im Bild sichtbare Standard-Ökosystem- und Hardware-Merkmale:
   • IKEA Skådis Lochmuster:
     • Horizontaler Mittenabstand der Schlitze in derselben Reihe: 40.0 mm
     • Vertikaler Reihenabstand: 20.0 mm (alternierende Reihen horizontal um 20.0 mm versetzt)
     • Schlitzabmessungen: 5.0 mm breit $\times$ 15.0 mm hoch (Stadion-/Langloch: 10.0 mm gerader vertikaler Mittenabstand mit R = 2.5 mm vollrunden Enden)
     • Standardplattenstärke: 5.0 mm (3.2 mm – 4.0 mm bei 3D-gedruckten modularen Lochplatten-Panels)
   • Elektronik & Mechanische Hardware:
     • Mechanischer Tastatur MX-Schalterausschnitt: 14.0 x 14.0 mm (1u Tastenabstand = 19.05 mm)
     • Standard-Smartphone-Breite (z. B. wenn auf einem Ständer liegend): ~71.5 mm
     • USB-C Buchsenöffnung: 8.94 x 3.26 mm
     • Verbindungselemente: M3 Zylinderkopf-Durchmesser = 5.5 mm (Durchgangsloch = 3.2–3.4 mm), M4 Kopf = 7.0 mm
3. Priorität 3 — Ergonomische / Handreferenz:
   • Wenn menschliche Hände das Teil halten und kein Hardware-Datum existiert, verwende die durchschnittliche Daumenbreite eines Erwachsenen (~20.0 mm) oder Handbreite (~85.0 mm) und lege die Gesamtbreite als einen Master-Fusion-Benutzerparameter (Tray_Width) offen, damit der Benutzer mit einem Klick neu skalieren kann.

---

Phase 3: Kinematische & Strukturelle Zerlegung (BOM)

Zerlege die Baugruppe in eine strukturierte Komponenten-Stückliste (BOM), bevor ein Fusion MCP Skript geschrieben wird:

1. Klassifiziere fixe vs. bewegliche Komponenten:
   • Feste Basis-/Rahmenkomponenten: z. B. Top_Anchor_Tray, Rear_Support_Legs (reichen bis zur Bodenebene $Z = 0$ hinunter) und Backboard_Pegboard_Panels.
   • Angetriebene / Koppelkomponenten: z. B. Stepped_Trays (Stufe 2..N), Schubladen oder Drehtüren.
   • Gelenk-/Verbindungskomponenten: z. B. Parallel_Link_Bars, Side_Joiner_Clips (H-Clips zum Verbinden geteilter Lochplattenhälften), Pivot_Pins.
   • Modulare Einsätze / Zubehör: z. B. Divider_Sub_Trays ($1/3$, $1/2$ oder $1/1$ Breite mit 1–3 Fächern), Skadis_Hooks.
2. Erzwinge kinematische Gesetze gegenüber perspektivischem Pixelrauschen:
   • Koplanares Echelon-Multi-Pin-Parallelogramm-Gesetz (nicht-überlappende Einzelschicht-Stangen): Zähle vor dem Modellieren eines Gelenks die exakte Anzahl der Stangen und Stifte pro Stange in den seitlichen orthografischen/perspektivischen Ansichten:
     • Gehe niemals davon aus, dass Gelenkstangen Stifte Ende-zu-Ende in überlappenden seitlichen Schichten teilen, wenn die Referenz parallele, nicht-überlappende koplanare Stangen zeigt (z. B. 4 parallele Stangen, angeordnet in einem Echelon: Stange 1 = 2-Stift kurze Stange, Stange 2 = 3-Stift lange Stange, Stange 3 = 3-Stift lange Stange, Stange 4 = 2-Stift kurze Stange).
     • In einem $N$-stufigen koplanaren Echelon-Gelenk hat jede Stufe $t \in {0, \dots, N-1}$ horizontale Stiftstationen $s \in {0, 1, 2}$ im Abstand von Pin_Station_Pitch $\Delta y_{\text{station}}$ entlang der Stufentiefe (Station A vorne, Station B mitte, Station C hinten), und jede Stange verbindet (Stufe $t$, Station $s$) $\longrightarrow$ (Stufe $t+1$, Station $s+1$) mit einem einstufigen Lochabstand $L_{\text{step}} = \sqrt{\Delta y_{\text{station}}^2 + \Delta Z_{\text{collapsed}}^2}$:
       • Stange 1 (2-Stift, Länge L_step): (Stufe 0, Station B) -> (Stufe 1, Station C)
       • Stange 2 (3-Stift, Länge 2*L_step): (Stufe 0, Station A) -> (Stufe 1, Station B) -> (Stufe 2, Station C)
       • Stange 3 (3-Stift, Länge 2*L_step): (Stufe 1, Station A) -> (Stufe 2, Station B) -> (Stufe 3, Station C)
       • Stange 4 (2-Stift, Länge L_step): (Stufe 2, Station A) -> (Stufe 3, Station B)
       • Bei einem Stangenwinkel $\theta$ zur Vertikalen beträgt die Stufe-zu-Stufe-Translation: $$\Delta Y_{\text{tray}}(\theta) = -L_{\text{step}}\sin(\theta) - \Delta y_{\text{station}}, \qquad \Delta Z_{\text{tray}}(\theta) = -L_{\text{step}}\cos(\theta)$$
       • Im kollabierten Zustand ($\theta_{\text{col}} = -\arcsin(\Delta y_{\text{station}} / L_{\text{step}})$) ist $\Delta Y_{\text{tray}} = + \Delta y_{\text{station}} - \Delta y_{\text{station}} = 0\text{ mm}$ (Stufen stapeln sich 100% vertikal, während die Stangen bei $-\theta_{\text{col}}$ sitzen und die Rückwände der Stufen bündig an der Vorderseite der hinteren Stützbeine anliegen).
       • Im offenen Zustand ($\theta_{\text{open}} = +\arcsin(\Delta y_{\text{station}} / L_{\text{step}})$) schwingen die exakt gleichen Stangen durch die Vertikale bis $+\theta_{\text{open}}$ und verschieben jede Stufe um $\Delta Y_{\text{tray}} = -2 \Delta y_{\text{station}}$ nach vorne, während alle 4 Stangen in einer einzigen koplanaren Schicht mit null gemeinsamen Stiften bleiben!
3. Druckbett-Modularitätsregel:
   • Wenn eine flache Platte (wie eine hohe Skådis Rückwand) die Ziel-Druckbetthöhe überschreitet (z. B. > 210 mm), teile sie horizontal in Upper_Panel und Lower_Panel und erzeuge passende seitliche H-Profil-Verbinderclips (0.20 mm Gleitspiel).
4. Optionale perspektivische Homographie-Entzerrung (--rectify):
   • Für schräg aufgenommene Fotos von flachen gemusterten Platten oder komplexen 2D-Silhouetten führe aus:

     ~/.gemini/antigravity/skills/media-to-fusion/scripts/process_media.py "<bildpfad>" \
       --out-dir ./media_workspace \
       --rectify "x1,y1,x2,y2,x3,y3,x4,y4" \
       --real-w <breite_mm> --real-h <hoehe_mm>
     

   • process_media.py sortiert automatisch die 4 Ecken im Uhrzeigersinn (TL, TR, BR, BL), entzerrt die Ebene zu rectified_ortho.png bei 0.1 mm/px, exportiert rectified_contour.dxf und speichert vereinfachte geschlossene Polygon-Loops (points_xy_mm) innerhalb von media_manifest.json.

---

Phase 4: Parametrische Modellierung über Fusion 360 MCP

Erstelle die CAD-Baugruppe sauber in Fusion 360 über execute_api_script:

1. Obligatorische Zentimeter-Konvertierung (cm = mm / 10.0):
   • Die interne API von Fusion 360 (adsk.core.ValueInput.createByReal(), adsk.core.Point3D.create()) verwendet strikt Zentimeter (cm).
   • Definiere immer def cm(mm_val): return mm_val / 10.0 am Anfang jedes execute_api_script.
2. Registriere Master-Benutzerparameter (design.userParameters): Erstelle zuerst bearbeitbare Millimeter-/Grad-Parameter, damit der Benutzer jederzeit Skalierung, Stufenanzahl oder Klappzustand neu konfigurieren kann:

   def set_user_param(design, name, expr_str, units="mm", comment=""):
       existing = design.userParameters.itemByName(name)
       if existing:
           existing.expression = expr_str
           return existing
       return design.userParameters.add(
           name, adsk.core.ValueInput.createByString(expr_str), units, comment
       )
   

   Empfohlene Parameter für faltbare/modulare Baugruppen:
   • Tray_Width, Tray_Depth, Tray_Height, Wall_Thickness (Standard 2.4 mm)
   • Link_Step_Pitch, Link_Width, Link_Thickness (Standard 3.5 mm)
   • Deploy_Angle_Deg (z. B. 40 deg für offenen/entfalteten Zustand, 0 deg für kollabierten vertikalen Stapel)
   • Clearance (Standard 0.25 mm)
3. Mechanische Toleranzen für den 3D-Druck:
   • Drehstifte / Gelenklöcher: 0.25 mm radiales (0.50 mm diametrales) Spiel, mit einer 0.8 mm Lippe oder M3-Befestigungsbohrung, damit die Gelenke gesichert bleiben.
   • Gleitende Verbinderclips / herausnehmbare Unterteilungseinsätze: 0.20 mm Spiel pro Seite (0.40 mm Gesamtbreiten-/Tiefenabzug auf Einsatzwannen).
   • Bodenwanne-Ergonomie & Hintere Stützbeine:
     • Füge abgerundete längliche seitliche Griffausschnitte an der untersten Wanne hinzu, wenn im Referenzmedium sichtbar.
     • Stelle sicher, dass Rear_Support_Legs von der oberen Ankerwanne bis zur Bodenebene ($Z = Z_{\text{unterste_wanne_boden}}$) reichen, damit die Baugruppe im entfalteten Zustand eben steht.

---

Phase 5: Geschlossene visuelle & Interferenz-Überprüfung

Höre niemals nach einer blinden Skriptausführung auf. Führe sowohl eine visuelle als auch eine mathematische Überprüfung durch:

1. Multi-Winkel-Visualvergleich (get_screenshot):
   • Rufe das fusion-mcp-Tool get_screenshot auf mit:
     • view="iso-top-right", width=1024, height=1024
     • view="right", width=1024, height=1024 (entscheidend für die Inspektion der Gelenkstangenausrichtung, des Treppenwinkels und des Bodenkontakts der hinteren Beine!)
     • view="front", width=1024, height=1024 (entscheidend für die Inspektion der Skådis-Schlitzgittersymmetrie und der Teilerproportionen!)
   • Vergleiche die gerenderten Screenshots nebeneinander mit den Referenz-Keyframes/Fotos (keyframe_XX_grid.png / annotated_grid.png).
2. Automatisierte Timeline- & Interferenz-Überprüfung: Führe einen Verifikationsdurchlauf über execute_api_script aus, um native Festkörpergeometrie zu bestätigen und auf physische Kollisionen zwischen Komponenten zu prüfen:

   def run(context):
       import adsk.core, adsk.fusion
       app = adsk.core.Application.get()
       design = adsk.fusion.Design.cast(app.activeProduct)
       root = design.rootComponent
   
       assert root.sketches.count > 0, "Keine nativen Skizzen gefunden!"
       assert root.features.extrudeFeatures.count > 0, "Keine Extrusions-Features gefunden!"
       assert root.meshBodies.count == 0, "Verbotene MeshBody-Objekte erkannt!"
   
       # Sammle alle sichtbaren Festkörper über Vorkommen und Stamm hinweg
       bodies = adsk.core.ObjectCollection.create()
       for b in root.bRepBodies:
           if b.isVisible:
               bodies.add(b)
       for occ in root.allOccurrences:
           for b in occ.bRepBodies:
               if b.isVisible:
                   bodies.add(b)
   
       # Führe Kollisionserkennung durch
       collisions = design.findCollisions(bodies)
       print(f"Gefundene Kollisionen: {len(collisions)}")
   

3. Reparatur-Schleifen-Toleranz: Bei erkannten Inkonsistenzen korrigiere das MCP-Skript und führe die execute_api_script-Phase erneut aus, bis die Konturen visuell übereinstimmen und die Kollisionserkennung 0 Kollisionen meldet.

---

Phase 6: Export & Workflow-Abschluss

1. Export nach STEP / STL / 3MF:

   def run(context):
       import adsk.core, adsk.fusion
       app = adsk.core.Application.get()
       design = adsk.fusion.Design.cast(app.activeProduct)
       exportMgr = design.exportManager
       # STEP Export
       stepOptions = exportMgr.createSTEPExportOptions(outputPath("model.step"))
       exportMgr.execute(stepOptions)
       # STL Export (für 3D-Druck)
       stlOptions = exportMgr.createSTLExportOptions(outputPath("model.stl"))
       # Optionen setzen...
       exportMgr.execute(stlOptions)
   

2. Zusammenfassung & Übergabe: Halte dem Benutzer eine Erfolgszusammenfassung bereit:
   • Modellspeicherort & Exportdateien
   • Die wichtigsten Benutzerparameter (Tray_Width, Deploy_Angle_Deg usw.)
   • Erkannte Einschränkungen (z. B. fehlende detaillierte Innenansichten, geschätzte Dicken)
   • Ermutige den Benutzer, Federzinken, Käfigmuttern oder Löcher für die Kabelverwaltung hinzuzufügen, falls relevant.