Desktop app for designing parametric 3D models in CadQuery together with the coding agent of your choice
TypeScript 3d-modeling3d-printing3d-printing-toolsagentagentic-aiai-cadcadcadqueryclaude-codecodexelectronfemllmmacdmakeropencodeparametric-designpythonsteptext-to-cad
App: Explosionsansicht, erste Stufe (E56)
Kai-Jungsthoefelcfd1ac75cbbc
diff --git a/app/README.md b/app/README.mdindex 631090e..232bf34 100644--- a/app/README.md+++ b/app/README.md@@ -22,6 +22,7 @@ npm run test:editor # Editor: Höhe und Scrollen, Speichern nur auf Wunsch mnpm run test:measure # Messen: Fläche, Kante, Punkt, Abstand paralleler Ebenen, zweier Bohrungen, zweier Punkte, Punkt zur Ebene, Verdecktes, neuer Build, Vorschau (21 Prüfungen)npm run test:groups # Gruppen: eigene und importierte (STEP-Baugruppe), Baum, Aus-/Einblenden und Transparenz je Gruppe, Klick durch transparente Teile, Ausgabe-STEP (17 Prüfungen)npm run test:section # Schnitt: X/Y/Z und an Fläche, Eingabe der Lage, Seite wechseln, gefüllte und schraffierte Schnittfläche, Klicks durch den Schnitt, Wandstärke an der Kontur messen, neuer Build (26 Prüfungen)+npm run test:explode # Explosion: Richtungen aus Gruppen und Achsen der Normteile, Schieber, Wege, Auswahl in Einbaulage, Hervorhebung wandert mit, Messen setzt zusammen, Schnitt dazu, neuer Build (20 Prüfungen)npm run test:skills # Skills: Panel, Stufen Aus/Bei Bedarf/Immer (Kopie mit oder ohne Hinweis, project.json, zwei Listen in AGENTS.md), Einstellungen (Werte in der Kopie, Prüfung, Standard, vorab bei ausgeschaltetem Skill), Ansehen, An Agent geben, Sicherung geänderter Kopien, fehlende Dateien und falsche Listen nur gemeldet, Snapshot und ZIP, Kategorien, Stufen für neue Modelle (47 Prüfungen)npm run test:fasteners # Normteile: Maße aus den Tabellen, Lage (at, direction, on, sunk), Bohrungen und Mutternfallen ohne Überschneidung, Einsätze, Fehlermeldungen, Rolle hardware, Codeblock des Skills „Normteile“, in der App Baum, Auswahl und export --all (35 Prüfungen)npm test # alle neun@@ -37,13 +38,13 @@ npm test # alle neun|---|---|| `src/main/` | Hauptprozess: `projects.ts` (offenes Projekt, Speichern, Öffnen, Verlauf, Wiederherstellen), `git.ts` (mitgeliefertes Git über dugite), `zip.ts` (ZIP schreiben und sicher entpacken), `workspace.ts` (UUID-Arbeitsordner, Projektzustand doppelt, Projekt-Check nur melden), `build.ts` (Build als Einmal-Prozess mit Entprellung, Warteschlange, Zeitlimit), `measure.ts` (langlebiger Python-Messdienst, `soma serve`), `skills.ts` (Stufen der Skills: Kopie nach `.soma/skills/`, bei Bedarf mit Hinweis, zwei Listen in `AGENTS.md`, Sicherung abweichender Kopien), `dialogs.ts` (native Dialoge, im Test beantwortbar), `watcher.ts`, `terminals.ts` (node-pty, `soma` und `git` im PATH), `files.ts` (Pfadschutz, Dateien nach `inputs/`, Markierungen nach `.soma/feedback/`, Schreiben aus dem Editor mit Konfliktprüfung und Sicherung), `agents.ts` || `src/preload/` | Schmale, feste Schnittstelle zum Renderer (kein Node-Zugriff dort) |-| `src/renderer/` | Oberfläche: `main.ts` (Verdrahtung: Kopfzeile, Menüs, Auswahl, Übergabe an den Agenten, Startseite), `viewer.ts` (three.js, Klick auf Code, Ansichten, Drehpunkt, Schnittebene mit gefüllter Schnittfläche und Kontur, Vorschaubild, Bild für die Markierung), `viewcube.ts` (Ansichtswürfel in 3D), `sectiontool.ts` (Schnitt: Karte, Ebene, Text für den Agenten), `skills.ts` (Panel „Skills“), `markup.ts` (Zeichenfläche der Markierung, Formen als bearbeitbare Objekte), `measuretool.ts` (Messen: Ablauf, Karte, Text für den Agenten), `parts.ts` (Bauteilkarte als Baum mit Gruppen, Auge und Transparenz), `code.ts` (Code-Panel mit Editor: CodeMirror 6, Speichern auf Wunsch, Abgleich mit Änderungen des Agenten, Konflikte, Umschalter für Markdown), `markdown.ts` (Markdown als Dokument: Tokens von `marked` direkt als DOM, ohne `innerHTML`), `filetree.ts` (Dateien-Panel), `versions.ts` (Verlaufsleiste), `terminals.ts` (xterm.js, Tabs, Einklappen, Einfügen), `ui.ts` (Menüs, Meldungen, Helfer), `icons.ts` (Symbole), `style.css` (Farben mit fester Bedeutung, siehe Kopf der Datei) |+| `src/renderer/` | Oberfläche: `main.ts` (Verdrahtung: Kopfzeile, Menüs, Auswahl, Übergabe an den Agenten, Startseite), `viewer.ts` (three.js, Klick auf Code, Ansichten, Drehpunkt, Schnittebene mit gefüllter Schnittfläche und Kontur, verschobene Bauteile der Explosion mit Wegen, Vorschaubild, Bild für die Markierung), `viewcube.ts` (Ansichtswürfel in 3D), `sectiontool.ts` (Schnitt: Karte, Ebene, Text für den Agenten), `explodetool.ts` (Explosion: Richtungen je Bauteil, Karte, Text für den Agenten), `skills.ts` (Panel „Skills“), `markup.ts` (Zeichenfläche der Markierung, Formen als bearbeitbare Objekte), `measuretool.ts` (Messen: Ablauf, Karte, Text für den Agenten), `parts.ts` (Bauteilkarte als Baum mit Gruppen, Auge und Transparenz), `code.ts` (Code-Panel mit Editor: CodeMirror 6, Speichern auf Wunsch, Abgleich mit Änderungen des Agenten, Konflikte, Umschalter für Markdown), `markdown.ts` (Markdown als Dokument: Tokens von `marked` direkt als DOM, ohne `innerHTML`), `filetree.ts` (Dateien-Panel), `versions.ts` (Verlaufsleiste), `terminals.ts` (xterm.js, Tabs, Einklappen, Einfügen), `ui.ts` (Menüs, Meldungen, Helfer), `icons.ts` (Symbole), `style.css` (Farben mit fester Bedeutung, siehe Kopf der Datei) || `src/shared/` | `types.ts` Typen des IPC-Vertrags, `editable.ts` welche Dateien der Editor nur zeigt (gilt in Renderer und Hauptprozess) || `resources/template/` | Vorlage für neue Projekte: `model.py`, `AGENTS.md`, `CLAUDE.md`, `NOTES.md`, `.gitignore` || `resources/skills/` | Mitgelieferte Skills (E17), je eine Markdown-Datei: Kopf mit `title`, `summary`, `topics`, `category` (deutsch, Oberfläche), `name` und `when` (englisch, für `AGENTS.md`: Name und Anlass), `order`, `default:` (Stufe bei neuen Modellen: `always`, `on-demand` oder `off`) und optional Einstellungen als `var name: Standard \| Einheit \| Bezeichnung \| 10..85` oder `\| a, b=Anzeige`, darunter die Regeln für den Agenten auf Englisch mit Platzhaltern `{{name}}` || `resources/icon.*` | App-Icon (E44) für Fenster und Taskleiste: `icon.svg` als Vorlage, `icon.ico` (16 bis 256 px) und `icon.png`. Neu erzeugen mit `python scripts/make-icon.py` (braucht Edge und Pillow, kleine Größen bekommen einen dickeren Strich) || `../python/soma/` | Hilfsbibliothek und Kommandozeile (`soma build`, `soma export`, `soma glb` für Vorschauen, `soma serve` Messdienst, `measure.py` exakte Werte mit OCC, `fasteners.py` Normteile mit Tabellen aus bd_warehouse in `data/fasteners/`) |-| `test/` | `smoke.mjs`, `versions.mjs`, `editor.mjs`, `measure.mjs`, `groups.mjs`, `section.mjs`, `skills.mjs` (Ende-zu-Ende), `unit.mjs` (ohne Electron), `harness.mjs` (App starten und steuern), `cdp.mjs` (kleiner DevTools-Client, puppeteer scheitert an Electron 44) |+| `test/` | `smoke.mjs`, `versions.mjs`, `editor.mjs`, `measure.mjs`, `groups.mjs`, `section.mjs`, `explode.mjs`, `skills.mjs`, `fasteners.mjs` (Ende-zu-Ende), `unit.mjs` (ohne Electron), `harness.mjs` (App starten und steuern), `cdp.mjs` (kleiner DevTools-Client, puppeteer scheitert an Electron 44) |## Noch nicht enthalten (siehe PLAN.md, Abschnitt 10)diff --git a/app/package.json b/app/package.jsonindex 1d07c82..2c7d69c 100644--- a/app/package.json+++ b/app/package.json@@ -14,10 +14,11 @@"test:measure": "npm run build && node test/measure.mjs","test:groups": "npm run build && node test/groups.mjs","test:section": "npm run build && node test/section.mjs",+ "test:explode": "npm run build && node test/explode.mjs","test:skills": "npm run build && node test/skills.mjs","test:fasteners": "npm run build && node test/fasteners.mjs","test:unit": "node test/unit.mjs",- "test": "npm run build && node test/unit.mjs && node test/smoke.mjs && node test/versions.mjs && node test/editor.mjs && node test/measure.mjs && node test/groups.mjs && node test/section.mjs && node test/skills.mjs && node test/fasteners.mjs"+ "test": "npm run build && node test/unit.mjs && node test/smoke.mjs && node test/versions.mjs && node test/editor.mjs && node test/measure.mjs && node test/groups.mjs && node test/section.mjs && node test/explode.mjs && node test/skills.mjs && node test/fasteners.mjs"},"dependencies": {"@codemirror/autocomplete": "^6.20.3",diff --git a/app/src/renderer/explodetool.ts b/app/src/renderer/explodetool.tsnew file mode 100644index 0000000..7cad6d2--- /dev/null+++ b/app/src/renderer/explodetool.ts@@ -0,0 +1,235 @@+import type { ExplodePart, Viewer } from './viewer';++interface Ui {+ card: HTMLElement;+ /** Knopf „Explosion“ im Viewer, Schließen in der Karte. */+ button: HTMLButtonElement; close: HTMLButtonElement;+ range: HTMLInputElement; value: HTMLElement; hint: HTMLElement;+ trails: HTMLButtonElement; fit: HTMLButtonElement;+ /** Bekommt die Klasse `exploding`, solange die Karte offen ist (ein offener Schnitt rückt dann darüber). */+ viewerEl: HTMLElement;+}+interface Deps {+ viewer: Viewer;+ /** Vor dem Einschalten: Gemessen wird nur in Einbaulage, die exakte Geometrie kennt keine Explosion. */+ beforeOn: () => void;+ /** Die Bauteile stehen still (Schieber losgelassen, Bewegung zu Ende), etwa für den Bereich des Schnitts. */+ settled: () => void;+}++/**+ * Abstand bei 100 % als Vielfaches des Abstands der Mitten. Gruppen rücken weiter auseinander als die Teile in ihnen, so+ * bleiben sie als Gruppe erkennbar. Geöffnet wird bei OPEN_AMOUNT, der Schieber reicht für weit verschachtelte Teile bis 100 %.+ */+const GROUP_WEIGHT = 3.2;+const PART_WEIGHT = 2;+const OPEN_AMOUNT = 0.5;+const MOVE_MS = 450;+/** Achsen gelten als gleich, wenn sie höchstens etwa 2,5° auseinanderliegen. */+const SAME_AXIS = 0.999;++type Vec = number[];+const add = (a: Vec, b: Vec) => a.map((x, i) => x + b[i]);+const sub = (a: Vec, b: Vec) => a.map((x, i) => x - b[i]);+const scale = (a: Vec, k: number) => a.map((x) => x * k);+const dot = (a: Vec, b: Vec) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];++/** Knoten im Baum der Gruppen: eine Gruppe oder ein Bauteil. `axis`: gemeinsame Achse aller Bauteile darunter, sonst null. */+interface Node {+ part?: ExplodePart; children: Node[]; byName: Map<string, Node>;+ min: Vec; max: Vec; axis: Vec | null; span: [number, number] | null;+}++const node = (part?: ExplodePart): Node => ({ part, children: [], byName: new Map(), min: [0, 0, 0], max: [0, 0, 0], axis: null, span: null });+const center = (n: Node) => n.min.map((x, i) => (x + n.max[i]) / 2);++function finish(n: Node): void {+ if (n.part) {+ n.min = n.part.min; n.max = n.part.max;+ n.axis = n.part.axis;+ n.span = n.part.axis ? n.part.span : null;+ return;+ }+ n.children.forEach(finish);+ n.min = [0, 1, 2].map((k) => Math.min(...n.children.map((c) => c.min[k])));+ n.max = [0, 1, 2].map((k) => Math.max(...n.children.map((c) => c.max[k])));+ const a = n.children[0]?.axis ?? null;+ n.axis = a && n.children.every((c) => c.axis && dot(c.axis, a) > SAME_AXIS) ? a : null;+ const spans = n.children.map((c) => c.span).filter((s): s is [number, number] => !!s);+ n.span = n.axis && spans.length ? [Math.min(...spans.map((s) => s[0])), Math.max(...spans.map((s) => s[1]))] : null;+}++function walk(n: Node, acc: Vec, out: Map<string, Vec>): void {+ const c = center(n);+ for (const ch of n.children) {+ const v = sub(center(ch), c);+ const w = ch.part ? PART_WEIGHT : GROUP_WEIGHT;+ let s: Vec;+ if (!ch.axis) s = scale(v, w);+ else if (n.axis) s = scale(ch.axis, dot(v, ch.axis) * w); // innerhalb gleicher Achse: nur die Reihenfolge entlang der Achse+ else {+ // Normteil verlässt sein Bauteil: aus dem Material heraus, dazu die eigene Länge (bei OPEN_AMOUNT ist es dann aus der Bohrung)+ const len = ch.span ? ch.span[1] - ch.span[0] : 0;+ s = scale(ch.axis, (Math.max(dot(v, ch.axis), 0) + len) * w);+ }+ const next = add(acc, s);+ if (ch.part) out.set(ch.part.id, next); else walk(ch, next, out);+ }+}++/**+ * Verschiebung jedes Bauteils bei voller Explosion (100 %), ohne KI, allein aus der Lage der Bauteile:+ * - Die Bauteile bilden einen Baum aus ihren Gruppen. Jeder Knoten rückt von der Mitte seines Elternknotens weg, um ein+ * Vielfaches des Abstands seiner Mitte zu ihr (Mitte des Hüllquaders, Teile PART_WEIGHT, Gruppen GROUP_WEIGHT). Die+ * Schritte addieren sich entlang des Pfads. Ein Bauteil genau in der Mitte bleibt stehen.+ * - Normteile (und Gruppen, deren Teile alle dieselbe Achse haben) bewegen sich nur entlang ihrer Achse aus dem Material+ * heraus: um ihren Abstand in Achsrichtung (nicht negativ) plus ihre Länge. Seitlich würden sie durch die Wand fahren.+ * - Referenzen bleiben stehen und zählen für die Mitten nicht mit (sie sind Umgebung, nicht Teil der Konstruktion).+ */+export function explodeSpreads(parts: ExplodePart[]): Map<string, Vec> {+ const out = new Map<string, Vec>();+ const root = node();+ for (const p of parts) {+ if (p.role === 'reference') continue;+ let n = root;+ for (const seg of (p.group ?? '').split('/').map((s) => s.trim()).filter(Boolean)) {+ let g = n.byName.get(seg);+ if (!g) { g = node(); n.byName.set(seg, g); n.children.push(g); }+ n = g;+ }+ n.children.push(node(p));+ }+ if (!root.children.length) return out;+ finish(root);+ walk(root, [0, 0, 0], out);+ return out;+}++/**+ * Explosionsansicht: Die Bauteile rücken auseinander, gesteuert über einen Schieber (0–100 %). Die Richtungen bestimmt+ * explodeSpreads. Ändert nichts am Modell und wird nicht gespeichert. Gemessen wird nur in Einbaulage (Messen setzt zusammen).+ */+export class ExplodeTool {+ private active = false;+ /** Stand des Schiebers (0..1). Bleibt für das nächste Einschalten. */+ private amount = OPEN_AMOUNT;+ /** Gezeigter Anteil, während einer Bewegung zwischen altem und neuem Wert. */+ private shown = 0;+ private spreads = new Map<string, Vec>();+ private moving = 0;+ private refs = 0;+ private trails = true;+ private anim: { stop(): void } | null = null;++ constructor(private ui: Ui, private deps: Deps) {+ ui.button.addEventListener('click', () => this.setActive(!this.active));+ ui.close.addEventListener('click', () => this.setActive(false));+ ui.range.addEventListener('input', () => {+ this.amount = Math.min(1, Math.max(0, Number(ui.range.value) / 100));+ this.stopAnim();+ this.show(this.amount);+ this.render();+ });+ ui.range.addEventListener('change', () => this.deps.settled());+ ui.trails.addEventListener('click', () => { this.trails = !this.trails; this.deps.viewer.setTrails(this.trails); this.render(); });+ ui.fit.addEventListener('click', () => this.deps.viewer.setView('fit'));+ this.deps.viewer.setTrails(this.trails);+ this.render();+ }++ get isActive(): boolean { return this.active; }++ /** Ein- oder ausschalten. Mit `animate` gleiten die Bauteile, ohne springen sie (etwa wenn Messen übernimmt). */+ setActive(on: boolean, animate = true): void {+ if (on !== this.active) {+ this.active = on;+ this.ui.button.setAttribute('aria-pressed', String(on));+ this.ui.card.hidden = !on;+ this.ui.viewerEl.classList.toggle('exploding', on);+ if (on) { this.deps.beforeOn(); this.compute(); }+ }+ const target = on ? this.amount : 0;+ if (animate) this.moveTo(target);+ else if (this.anim || this.shown !== target) { this.stopAnim(); this.show(target); this.deps.settled(); }+ this.render();+ }++ /** Neues Modell (Build oder anderer Stand): Richtungen neu bestimmen, die Explosion bleibt so weit, wie sie war. */+ refresh(): void {+ this.compute();+ if (this.shown > 0) this.show(this.shown);+ this.render();+ }++ /** Beschreibung für den Agenten, etwa beim Markieren. Ohne Explosion null. */+ agentText(): string | null {+ if (!this.active || this.shown <= 0 || !this.moving) return null;+ return `Explosionsansicht (${Math.round(this.shown * 100)} %): Die Bauteile sind nur zur Darstellung auseinandergezogen, ihre Lage im Bild ist nicht die Einbaulage`;+ }++ private compute(): void {+ const parts = this.deps.viewer.explodeParts();+ this.spreads = explodeSpreads(parts);+ this.refs = parts.filter((p) => p.role === 'reference').length;+ this.moving = [...this.spreads.values()].filter((s) => Math.hypot(s[0], s[1], s[2]) > 1e-6).length;+ }++ private show(t: number): void {+ this.shown = t;+ if (t <= 0) { this.deps.viewer.setOffsets(null); return; }+ const m = new Map<string, Vec>();+ for (const [id, s] of this.spreads) m.set(id, scale(s, t));+ this.deps.viewer.setOffsets(m);+ }++ /** Gleitend zum Ziel. Ohne Bildwiederholung (unsichtbares Fenster) steht sie nach Ablauf trotzdem dort. */+ private moveTo(target: number): void {+ this.stopAnim();+ const from = this.shown;+ if (Math.abs(target - from) < 1e-9) { this.show(target); return; }+ const t0 = performance.now();+ let raf = 0, done = false;+ const stop = () => { done = true; cancelAnimationFrame(raf); clearTimeout(timer); if (this.anim === handle) this.anim = null; };+ const finish = () => { if (done) return; stop(); this.show(target); this.deps.settled(); };+ const tick = () => {+ if (done) return;+ const k = Math.min(1, (performance.now() - t0) / MOVE_MS);+ if (k >= 1) { finish(); return; }+ this.show(from + (target - from) * (k < 0.5 ? 2 * k * k : 1 - (-2 * k + 2) ** 2 / 2));+ raf = requestAnimationFrame(tick);+ };+ const timer = setTimeout(finish, MOVE_MS + 60);+ const handle = { stop };+ this.anim = handle;+ raf = requestAnimationFrame(tick);+ }++ private stopAnim(): void { this.anim?.stop(); }++ private render(): void {+ const { ui } = this;+ const pct = Math.round(this.amount * 100);+ ui.range.min = '0'; ui.range.max = '100'; ui.range.step = '1';+ ui.range.value = String(pct);+ ui.value.textContent = `${pct} %`;+ ui.trails.setAttribute('aria-pressed', String(this.trails));+ if (!this.active) return;+ let hint: string;+ if (!this.spreads.size) hint = 'Keine Bauteile zum Auseinanderziehen.';+ else if (!this.moving) hint = 'Nur ein Bauteil, da rückt nichts auseinander.';+ else hint = 'Teile rücken von der Mitte weg, Gruppen gemeinsam, Normteile entlang ihrer Achse.';+ if (this.refs && this.spreads.size) hint += ' Referenzen bleiben stehen.';+ ui.hint.textContent = hint;+ // Ein offener Schnitt steht über dieser Karte (style.css), ihre Höhe hängt am Hinweis+ ui.viewerEl.style.setProperty('--excard-h', `${ui.card.offsetHeight}px`);+ }++ /** Für Tests. */+ state() {+ return {+ active: this.active, amount: this.amount, shown: this.shown, trails: this.trails, moving: this.moving, animating: !!this.anim,+ spreads: Object.fromEntries([...this.spreads].map(([id, s]) => [id, s.map((v) => +v.toFixed(4))])),+ text: this.ui.card.innerText, agent: this.agentText(),+ };+ }+}diff --git a/app/src/renderer/icons.ts b/app/src/renderer/icons.tsindex f05ad8f..60ee46d 100644--- a/app/src/renderer/icons.ts+++ b/app/src/renderer/icons.ts@@ -19,6 +19,7 @@ const PATHS: Record<string, string> = {layers: '<path d="m12 3 9 5-9 5-9-5z"/><path d="m3 13 9 5 9-5"/>',ruler: '<path d="M3 17 17 3l4 4L7 21z"/><path d="m7 13 2 2M10 10l2 2M13 7l2 2"/>',section: '<path d="M5 9 12 5l7 4v8l-7 4-7-4z"/><path d="M2 13h20"/>',+ explode: '<rect x="9" y="9" width="6" height="6" rx="1"/><path d="M4 4l3 3M20 4l-3 3M4 20l3-3M20 20l-3-3M4 8V4h4M16 4h4v4M4 16v4h4M20 16v4h-4"/>',flip: '<path d="M7 4 3 8l4 4M3 8h14M17 12l4 4-4 4M21 16H7"/>',camera: '<path d="M4 8h3l2-3h6l2 3h3a1 1 0 0 1 1 1v9a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V9a1 1 0 0 1 1-1z"/><circle cx="12" cy="13" r="3.5"/>',fit: '<path d="M4 9V4h5M20 9V4h-5M4 15v5h5M20 15v5h-5"/>', home: '<path d="M3 11 12 4l9 7"/><path d="M5 10v10h14V10"/>',diff --git a/app/src/renderer/index.html b/app/src/renderer/index.htmlindex 4b66399..0a3399b 100644--- a/app/src/renderer/index.html+++ b/app/src/renderer/index.html@@ -89,6 +89,7 @@<span class="vsep"></span><button id="btn-measure" aria-pressed="false" title="Messen: Fläche oder Kante anklicken, ein zweiter Klick misst Abstand und Winkel (exakte Werte)"><i data-icon="ruler"></i><span class="lbl">Messen</span></button><button id="btn-section" aria-pressed="false" title="Schnitt: das Modell an einer Ebene aufschneiden (senkrecht zu X, Y, Z oder parallel zu einer Fläche)"><i data-icon="section"></i><span class="lbl">Schnitt</span></button>+ <button id="btn-explode" aria-pressed="false" title="Explosion: die Bauteile zur Darstellung auseinanderziehen, Normteile entlang ihrer Achse"><i data-icon="explode"></i><span class="lbl">Explosion</span></button><span class="vsep"></span><button id="btn-mark" title="Viewer-Bild markieren und an den Agenten geben"><i data-icon="camera"></i><span class="lbl">Markieren</span></button></div>@@ -145,6 +146,22 @@</div></div>+ <!-- Explosionsansicht (explodetool.ts): Bauteile auseinanderziehen. Ändert nichts am Modell. -->+ <div id="explode-card" class="float excard" hidden>+ <div class="mc-hd"><span class="mc-ico"><i data-icon="explode" data-size="16"></i></span><b>Explosion</b><span class="grow"></span>+ <button id="btn-explode-close" class="ibtn s" aria-label="Explosion beenden" title="Explosion beenden (setzt das Modell wieder zusammen)"><i data-icon="x" data-size="14" data-stroke="2"></i></button></div>+ <div class="sx-pos">+ <label for="explode-range">Abstand</label>+ <input id="explode-range" type="range" min="0" max="100" step="1" aria-label="Abstand der Explosion in Prozent">+ <span id="explode-value" class="ex-val"></span>+ </div>+ <div id="explode-hint" class="mc-hint"></div>+ <div class="sc-actions">+ <button id="btn-explode-trails" class="btn sm" aria-pressed="true" title="Gestrichelte Wege von der Einbaulage zur aktuellen Lage zeigen"><i data-icon="line" data-size="14" data-stroke="1.9"></i>Wege</button>+ <button id="btn-explode-fit" class="btn sm" title="Das auseinandergezogene Modell ganz ins Bild holen"><i data-icon="fit" data-size="14" data-stroke="1.9"></i>Einpassen</button>+ </div>+ </div>+<div id="errcard" class="float errcard" hidden><div class="ec-hd"><span class="err-ico"><i data-icon="alert" data-size="18"></i></span><div class="ec-title"><b>Build fehlgeschlagen</b><span id="err-where" class="c2"></span></div><span class="grow"></span>diff --git a/app/src/renderer/main.ts b/app/src/renderer/main.tsindex 5abd16f..28b430a 100644--- a/app/src/renderer/main.ts+++ b/app/src/renderer/main.ts@@ -7,6 +7,7 @@ import { Markup } from './markup';import { MAX_QUOTE } from './pdfview';import { MeasureTool } from './measuretool';import { SectionTool } from './sectiontool';+import { ExplodeTool } from './explodetool';import { SkillsPanel } from './skills';import { PartsCard } from './parts';import { TerminalTabs } from './terminals';@@ -330,6 +331,21 @@ const sectionTool = new SectionTool({hint: $('section-hint'), flip: $<HTMLButtonElement>('btn-section-flip'), look: $<HTMLButtonElement>('btn-section-look'),}, { viewer });+// ---- Explosionsansicht (E56) ----------------------------------------------------------------------------------------++const explodeTool = new ExplodeTool({+ card: $('explode-card'), button: $<HTMLButtonElement>('btn-explode'), close: $<HTMLButtonElement>('btn-explode-close'),+ range: $<HTMLInputElement>('explode-range'), value: $('explode-value'), hint: $('explode-hint'),+ trails: $<HTMLButtonElement>('btn-explode-trails'), fit: $<HTMLButtonElement>('btn-explode-fit'), viewerEl: $('viewer'),+}, {+ viewer,+ beforeOn: () => { if (measureTool.isActive) measureTool.setActive(false); },+ settled: () => sectionTool.refresh(), // der Bereich des Schiebers folgt den verschobenen Bauteilen+});+// Gemessen wird in Einbaulage (die exakte Geometrie kennt keine Explosion): Messen setzt das Modell sofort zusammen.+// Nach dem Knopf-Handler von MeasureTool registriert, isActive ist hier schon umgeschaltet.+$('btn-measure').addEventListener('click', () => { if (measureTool.isActive) explodeTool.setActive(false, false); });+// ---- Markierung (E16) -------------------------------------------------------------------------------------------const markup = new Markup({@@ -410,10 +426,10 @@ async function sendMarkup(): Promise<void> {const old = versions.previewed, source = markup.source;markup.close();void refreshFiles(); // die neue Markierung steht gleich im Dateibaum- // Zeigt das Bild einen alten Stand oder einen Schnitt, soll der Agent das wissen (sonst vergleicht er es mit dem aktuellen Code- // oder hält die Schnittfläche für eine echte Fläche)+ // Zeigt das Bild einen alten Stand, einen Schnitt oder eine Explosion, soll der Agent das wissen (sonst vergleicht er es mit dem+ // aktuellen Code, hält die Schnittfläche für eine echte Fläche oder die auseinandergezogenen Teile für ihre Lage)// Auf einem Bild aus dem Projekt gezeichnet: Der Agent soll das Original kennen, Stand und Schnitt spielen dann keine Rolle- const cut = sectionTool.agentText();+ const cut = [sectionTool.agentText(), explodeTool.agentText()].filter(Boolean).join(', ');const note = source ? `, gezeichnet auf ${source}`: (old ? `, zeigt den älteren Stand ${old.short} "${old.subject.slice(0, 80)}"` : '') + (cut ? `, ${cut}` : '');insertToAgent(`[Markierung: ${r.path}${note}] `, `Markierung gespeichert: ${r.path}`);@@ -543,6 +559,7 @@ async function loadModel(): Promise<void> {textCache.clear();await viewer.load(glb);measureTool.reset(); // neuer Build: die Nummern der Flächen und Kanten gelten nicht mehr+ explodeTool.refresh(); // vor dem Schnitt: Dessen Bereich hängt von der Lage der Bauteile absectionTool.refresh();msg.className = ''; msg.textContent = '';refreshPartsCard();@@ -578,6 +595,7 @@ const versions = new VersionsBar({textCache.clear();await viewer.load(res.glb);measureTool.reset();+ explodeTool.refresh();sectionTool.refresh();refreshPartsCard();selectPart(null, null);@@ -599,6 +617,7 @@ async function onProject(p: ProjectInfo): Promise<void> {markup.close();if (measureTool.isActive) measureTool.setActive(false);sectionTool.setActive(false);+ explodeTool.setActive(false, false);viewer.clear();versions.reset();terminals.closeAll();@@ -987,6 +1006,7 @@ if (api.testMode) {markup: () => markup.state(),measure: () => measureTool.state(),section: () => sectionTool.state(),+ explode: () => explodeTool.state(),skills: () => skills.state(),pick: () => selection?.pick ?? null,markPixel: (x: number, y: number) => markup.pixel(x, y),diff --git a/app/src/renderer/style.css b/app/src/renderer/style.cssindex b7c0219..fe731dc 100644--- a/app/src/renderer/style.css+++ b/app/src/renderer/style.css@@ -577,3 +577,10 @@ code { font-family:var(--mono); font-size:.95em; }.note-ico { color:var(--vio); display:flex; }.note-text { display:flex; flex-direction:column; gap:8px; font-size:12.5px; }.note-text .btn { align-self:flex-start; }+/* Explosionsansicht (explodetool.ts): Karte unten rechts. Ein offener Schnitt rückt darüber (schmal steht er ohnehin oben). */+.excard { right:14px; bottom:12px; width:300px; overflow:hidden; }+.excard .sx-pos label { width:52px; }+.ex-val { width:42px; flex-shrink:0; text-align:right; font:12px var(--mono); color:var(--tx2); }+.excard .btn[aria-pressed=true] { background:var(--acc-tint); color:var(--acc-tx); border-color:var(--acc-line); }+@container viewer (min-width: 761px) { #viewer.exploding .sectcard { bottom:calc(var(--excard-h, 176px) + 24px); } }+@container viewer (max-width: 760px) { .excard { width:272px; } }diff --git a/app/src/renderer/viewer.ts b/app/src/renderer/viewer.tsindex 89a9b0c..2b95bfc 100644--- a/app/src/renderer/viewer.ts+++ b/app/src/renderer/viewer.ts@@ -12,10 +12,15 @@ THREE.Object3D.DEFAULT_UP.set(0, 0, 1);interface FaceEntry { id: number; surface: string; area?: number; center?: number[]; triStart: number; triCount: number }interface EdgeEntry { id: number; curve: string; length?: number; segStart: number; segCount: number }interface VertexEntry { id: number; p: number[] }-/** `solid`: geschlossener Körper (fehlt bei älteren Builds, gilt dann als geschlossen). Nur dann füllt der Schnitt die Schnittfläche. */-interface PartMeta { partId: string; name: string; role: string; group?: string | null; solid?: boolean; faces: FaceEntry[]; edges?: EdgeEntry[]; vertices?: VertexEntry[] }+/**+ * `solid`: geschlossener Körper (fehlt bei älteren Builds, gilt dann als geschlossen). Nur dann füllt der Schnitt die Schnittfläche.+ * `axis`: nur bei Normteilen, Richtung aus dem Material heraus. Daran zieht die Explosionsansicht sie heraus.+ */+interface PartMeta { partId: string; name: string; role: string; group?: string | null; solid?: boolean; axis?: number[]; faces: FaceEntry[]; edges?: EdgeEntry[]; vertices?: VertexEntry[] }interface PartEntry {group: THREE.Object3D; meta: PartMeta; meshes: THREE.Mesh[]; lines: THREE.LineSegments[];+ /** Lage des Knotens laut GLB (Einbaulage) und die Verschiebung der Explosionsansicht davon weg. */+ base: THREE.Vector3; offset: THREE.Vector3;/** Deckel der Schnittfläche: Zählnetze für den Schablonenpuffer und die Platte in der Ebene (erst beim ersten Schnitt angelegt). */cap?: { stencils: THREE.Mesh[]; plate: THREE.Mesh };/** Dreiecke in Weltkoordinaten, für die Schnittkontur und den Bereich des Schiebers (erst bei Bedarf berechnet). */@@ -39,6 +44,12 @@ export interface SectionPlane { normal: number[]; constant: number }/** Angeklickte Fläche, an der sich der Schnitt ausrichten soll. `normal` zeigt aus dem Material heraus. */export interface PlaneHit { partId: string; name: string; faceId: number; surface: string; normal: number[]; point: number[] }+/**+ * Bauteil in Einbaulage, Grundlage der Explosionsansicht. `min`/`max`: Hüllquader. `axis`: nur Normteile, Einheitsvektor aus+ * dem Material heraus, `span` ihre Ausdehnung entlang dieser Achse.+ */+export interface ExplodePart { id: string; group: string | null; role: string; min: number[]; max: number[]; axis: number[] | null; span: [number, number] | null }+export type ViewName = 'iso' | 'front' | 'back' | 'top' | 'bottom' | 'right' | 'left' | 'fit';/** Treffer beim Messen: Fläche, Kante oder Eckpunkt eines Bauteils, mit Punkt auf dem Netz (beim Eckpunkt seine Lage). */@@ -115,6 +126,9 @@ export class Viewer {/** Zu jedem Segment der Schnittkontur Bauteil und Fläche: Beim Messen lässt sich so die Kontur anklicken. */private contourOf: { part: PartEntry; face: number }[] = [];private contourDirty = false;+ /** Explosionsansicht: Wege der verschobenen Bauteile, gestrichelt von der Einbaulage zur aktuellen Lage. */+ private trails = new THREE.Group();+ private showTrails = true;/** Wartet auf einen Klick auf eine Fläche (Schnitt an Fläche ausrichten). */private planePick: ((h: PlaneHit | null) => void) | null = null;onPick: (r: PickResult | null) => void = () => {};@@ -135,7 +149,7 @@ export class Viewer {this.scene.add(new THREE.HemisphereLight(0xffffff, 0x445566, 1.6));const sun = new THREE.DirectionalLight(0xffffff, 2.2);sun.position.set(80, -120, 200);- this.scene.add(sun, this.highlight, this.hover, this.marks, this.caps);+ this.scene.add(sun, this.highlight, this.hover, this.marks, this.caps, this.trails);this.overlay = document.createElement('div');this.overlay.className = 'v-overlay';container.appendChild(this.overlay);@@ -189,7 +203,7 @@ export class Viewer {mat.userData.baseTransparent = mat.transparent;if (meta.role === 'reference') { mat.depthWrite = false; m.renderOrder = 1; }}- fresh.set(meta.partId, { group: o, meta, meshes, lines });+ fresh.set(meta.partId, { group: o, meta, meshes, lines, base: o.position.clone(), offset: new THREE.Vector3() });});this.clearCaps();this.disposeModel();@@ -205,8 +219,7 @@ export class Viewer {this.hoverKey = '';if (this.selectedId && !this.parts.has(this.selectedId)) this.selectedId = null;this.applySelection();- const box = this.bounds([...this.parts.keys()]);- if (!box.isEmpty()) { box.getCenter(this.center); this.radius = Math.max(box.getSize(new THREE.Vector3()).length() / 2, 1); }+ this.updateExtent();if (!this.hasFitted && this.parts.size) { this.setView('iso'); this.hasFitted = true; }this.fitClip();this.syncSection();@@ -222,6 +235,7 @@ export class Viewer {this.hasFitted = false;this.highlight.clear();this.clearGroup(this.hover);+ this.clearGroup(this.trails);this.setMeasureMarks(null);this.syncSection();this.requestRender();@@ -279,6 +293,7 @@ export class Viewer {private applyVisibility(): void {for (const [id, p] of this.parts) p.group.visible = !this.hidden.has(id);+ this.syncTrails();this.syncSection();}@@ -363,6 +378,12 @@ export class Viewer {return box;}+ /** Mitte und Radius aller Bauteile in ihrer aktuellen Lage (die Explosionsansicht vergrößert das Modell). */+ private updateExtent(): void {+ const box = this.bounds([...this.parts.keys()]);+ if (!box.isEmpty()) { box.getCenter(this.center); this.radius = Math.max(box.getSize(new THREE.Vector3()).length() / 2, 1); }+ }+setView(name: ViewName, ids?: string[]): void {const box = this.bounds(ids);if (box.isEmpty()) return;@@ -513,7 +534,8 @@ export class Viewer {return {partId: part.meta.partId, name: part.meta.name, role: part.meta.role,faceId: face?.id ?? null, surface: face?.surface ?? null, area: face?.area ?? null,- point: hit.point.toArray().map((v) => +v.toFixed(3)),+ // In Einbaulage: Die Explosionsansicht verschiebt nur die Darstellung, der Agent kennt nur das Modell+ point: hit.point.clone().sub(part.offset).toArray().map((v) => +v.toFixed(3)),...(hit.cut ? { cut: true } : {}),};}@@ -528,9 +550,28 @@ export class Viewer {color: 0xf29a38, transparent: true, opacity: 0.85, polygonOffset: true, polygonOffsetFactor: -2, polygonOffsetUnits: -2, side: THREE.DoubleSide,clippingPlanes: this.clip }));o.renderOrder = 2;+ this.attach(o, src);this.highlight.add(o);}+ /** Hervorhebung in den Koordinaten von `src` (Netz oder Knoten eines Bauteils): Sie wandert mit, wenn die Explosionsansicht es verschiebt. */+ private attach(o: THREE.Object3D, src: THREE.Object3D): void {+ o.matrixAutoUpdate = false;+ o.userData.follow = src;+ src.updateMatrixWorld();+ o.matrix.copy(src.matrixWorld);+ }++ /** Angehängte Hervorhebungen an die aktuelle Lage ihrer Bauteile setzen. */+ private follow(): void {+ for (const g of [this.highlight, this.hover, this.marks]) {+ for (const o of g.children) {+ const src = o.userData.follow as THREE.Object3D | undefined;+ if (src) { o.matrix.copy(src.matrixWorld); o.matrixWorldNeedsUpdate = true; }+ }+ }+ }+private installPicking(): void {const el = this.renderer.domElement;let down: [number, number] | null = null;@@ -771,10 +812,11 @@ export class Viewer {if (!vx) return;// Ein runder Punkt fester Bildgröße, immer sichtbar (Hervorhebung: größer, Auswahl in Orange)const g = new THREE.BufferGeometry();- g.setAttribute('position', new THREE.Float32BufferAttribute(new THREE.Vector3(...(vx.p as [number, number, number])).applyMatrix4(p.group.matrixWorld).toArray(), 3));+ g.setAttribute('position', new THREE.Float32BufferAttribute(vx.p.slice(0, 3), 3));const m = new THREE.PointsMaterial({ color, size: 6 + width * 3, sizeAttenuation: false, map: Viewer.dot(), transparent: true, alphaTest: 0.2, depthTest: false });const o = new THREE.Points(g, m);o.renderOrder = 11;+ this.attach(o, p.group);group.add(o);return;}@@ -794,6 +836,7 @@ export class Viewer {const o = new THREE.Mesh(g, new THREE.MeshBasicMaterial({ color, transparent: true, opacity, depthWrite: false, polygonOffset: true, polygonOffsetFactor: -2, polygonOffsetUnits: -2, side: THREE.DoubleSide,clippingPlanes: this.clip }));o.renderOrder = 3;+ this.attach(o, src);group.add(o);return;}@@ -801,12 +844,13 @@ export class Viewer {const l = p.lines[0];if (!edge || !l) return;const pos = l.geometry.getAttribute('position');- const v = new THREE.Vector3();const flat: number[] = [];for (let s = edge.segStart; s < edge.segStart + edge.segCount; s++) {- for (const k of [s * 2, s * 2 + 1]) { v.fromBufferAttribute(pos, k).applyMatrix4(l.matrixWorld); flat.push(v.x, v.y, v.z); }+ for (const k of [s * 2, s * 2 + 1]) flat.push(pos.getX(k), pos.getY(k), pos.getZ(k));}- group.add(this.fatLines(flat, color, width, false, true));+ const o = this.fatLines(flat, color, width, false, true);+ this.attach(o, l);+ group.add(o);}private static dotTexture: THREE.Texture | null = null;@@ -1041,7 +1085,7 @@ export class Viewer {return { partId: part.meta.partId, name: part.meta.name, faceId: face.id, surface: face.surface, normal: n.toArray(), point: point.toArray() };}- /** Dreiecke eines Bauteils in Weltkoordinaten (einmal berechnet, das Modell bewegt sich nicht). */+ /** Dreiecke eines Bauteils in Weltkoordinaten (einmal berechnet, bis die Explosionsansicht das Bauteil verschiebt). */private worldOf(p: PartEntry): NonNullable<PartEntry['world']> {if (p.world) return p.world;p.group.updateMatrixWorld(true);@@ -1206,8 +1250,95 @@ export class Viewer {this.scene.add(this.contour);}+ // ---- Explosionsansicht ----------------------------------------------------------------------------------------++ /** Alle Bauteile in Einbaulage, auch ausgeblendete: Die Explosion soll nicht springen, wenn man etwas aus- oder einblendet. */+ explodeParts(): ExplodePart[] {+ return [...this.parts.values()].map((p) => {+ const box = new THREE.Box3().setFromObject(p.group).translate(p.offset.clone().negate());+ const a = p.meta.axis;+ const axis = Array.isArray(a) && a.length === 3 && a.every(Number.isFinite) && Math.hypot(a[0], a[1], a[2]) > 1e-9+ ? new THREE.Vector3(a[0], a[1], a[2]).normalize() : null;+ let span: [number, number] | null = null;+ if (axis) {+ // Genau aus den Dreiecken, der Hüllquader wäre bei schräger Achse zu lang+ let lo = Infinity, hi = -Infinity;+ const shift = axis.dot(p.offset);+ for (const w of this.worldOf(p)) {+ for (let i = 0; i < w.pos.length; i += 3) {+ const v = axis.x * w.pos[i] + axis.y * w.pos[i + 1] + axis.z * w.pos[i + 2] - shift;+ if (v < lo) lo = v;+ if (v > hi) hi = v;+ }+ }+ if (lo <= hi) span = [lo, hi];+ }+ return { id: p.meta.partId, group: p.meta.group ?? null, role: p.meta.role, min: box.min.toArray(), max: box.max.toArray(),+ axis: axis ? axis.toArray() : null, span };+ });+ }++ /**+ * Bauteile aus der Einbaulage verschieben (nur verschieben, nicht drehen). Fehlende Bauteile und null: Einbaulage.+ * Klicks, Schnitt und Hervorhebungen arbeiten danach mit der neuen Lage.+ */+ setOffsets(offsets: Map<string, number[]> | null): void {+ for (const [id, p] of this.parts) {+ const o = offsets?.get(id);+ const next = new THREE.Vector3(o?.[0] ?? 0, o?.[1] ?? 0, o?.[2] ?? 0);+ if (next.equals(p.offset)) continue;+ p.offset.copy(next);+ p.group.position.copy(p.base).add(p.offset);+ p.group.updateMatrixWorld(true);+ p.world = undefined;+ }+ this.follow();+ this.updateExtent();+ this.syncTrails();+ this.syncSection();+ this.fitClip();+ this.requestRender();+ }++ /** Wege der Explosionsansicht zeigen oder nicht. */+ setTrails(on: boolean): void { this.showTrails = on; this.syncTrails(); this.requestRender(); }++ /** Gestrichelte Linie je verschobenem, sichtbarem Bauteil von seiner Mitte in Einbaulage zur aktuellen Mitte. */+ private syncTrails(): void {+ this.clearGroup(this.trails);+ if (!this.showTrails) return;+ const flat: number[] = [];+ const c = new THREE.Vector3();+ for (const p of this.parts.values()) {+ if (!p.group.visible || p.offset.length() < this.radius * 1e-3) continue;+ new THREE.Box3().setFromObject(p.group).getCenter(c);+ flat.push(c.x - p.offset.x, c.y - p.offset.y, c.z - p.offset.z, c.x, c.y, c.z);+ }+ if (!flat.length) return;+ const g = new LineSegmentsGeometry();+ g.setPositions(flat);+ // Mit Tiefe, anders als Messstrecken: Die Wege sollen hinter Bauteilen verschwinden, sonst überdecken sie das Bild+ const m = new LineMaterial({ color: 0x8d97a3, linewidth: 1.2, transparent: true, opacity: 0.85, dashed: true,+ dashSize: this.radius / 50, gapSize: this.radius / 70 });+ m.clippingPlanes = this.clip;+ m.resolution.set(this.container.clientWidth || 1, this.container.clientHeight || 1);+ this.lineMats.add(m);+ const l = new LineSegments2(g, m);+ l.computeLineDistances();+ l.raycast = () => {};+ this.trails.add(l);+ }+// ---- Prüfhilfen (nur für Tests) -------------------------------------------------------------------------------+ /** Verschiebung je Bauteil (nur verschobene) und Zahl der Wege, für Tests. */+ explodeState() {+ const offsets: Record<string, number[]> = {};+ for (const [id, p] of this.parts) if (p.offset.lengthSq() > 0) offsets[id] = p.offset.toArray().map((v) => +v.toFixed(4));+ const t = this.trails.children[0] as LineSegments2 | undefined;+ return { offsets, trails: t ? (t.geometry as LineSegmentsGeometry).getAttribute('instanceStart').count : 0, radius: this.radius };+ }+facesOf(partId: string): FaceEntry[] { return this.parts.get(partId)?.meta.faces ?? []; }/** Kanten eines Bauteils mit Mittelpunkt (Mitte des mittleren Segments) und dessen Bildschirmposition. */@@ -1218,9 +1349,11 @@ export class Viewer {const pos = l.geometry.getAttribute('position');const r = this.renderer.domElement.getBoundingClientRect();this.camera.updateMatrixWorld();+ l.updateMatrixWorld();return (p.meta.edges ?? []).map((e) => {const s = e.segStart + Math.floor(e.segCount / 2);- const a = new THREE.Vector3().fromBufferAttribute(pos, s * 2), b = new THREE.Vector3().fromBufferAttribute(pos, s * 2 + 1);+ const a = new THREE.Vector3().fromBufferAttribute(pos, s * 2).applyMatrix4(l.matrixWorld);+ const b = new THREE.Vector3().fromBufferAttribute(pos, s * 2 + 1).applyMatrix4(l.matrixWorld);const m = a.clone().lerp(b, 0.5);const v = m.clone().project(this.camera);return { id: e.id, curve: e.curve, length: e.length, mid: m.toArray(), screen: { x: r.left + ((v.x + 1) / 2) * r.width, y: r.top + ((1 - v.y) / 2) * r.height } };@@ -1303,7 +1436,7 @@ export class Viewer {screenOf(partId: string, faceId: number): { x: number; y: number } {const f = this.facesOf(partId).find((x) => x.id === faceId)!;this.camera.updateMatrixWorld();- const v = new THREE.Vector3(...(f.center as [number, number, number])).project(this.camera);+ const v = new THREE.Vector3(...(f.center as [number, number, number])).applyMatrix4(this.parts.get(partId)!.group.matrixWorld).project(this.camera);const r = this.renderer.domElement.getBoundingClientRect();return { x: r.left + ((v.x + 1) / 2) * r.width, y: r.top + ((1 - v.y) / 2) * r.height };}diff --git a/app/test/explode.mjs b/app/test/explode.mjsnew file mode 100644index 0000000..adab96f--- /dev/null+++ b/app/test/explode.mjs@@ -0,0 +1,188 @@+// Test der Explosionsansicht (E56): Richtungen aus Gruppen und Normteil-Achsen, Schieber, Wege, Auswahl in Einbaulage,+// Hervorhebung wandert mit, Messen setzt zusammen, Schnitt darüber, Ausblenden, neuer Build, Text für den Agenten.+// Aufruf: npm run test:explode (baut vorher). SMOKE_VISIBLE=offscreen SMOKE_SHOTS=1 legt Bilder ab.+import fs from 'node:fs';+import path from 'node:path';+import { APP, checker, cleanup, sleep, startApp } from './harness.mjs';++const t = checker();+const { check } = t;+let app;++// Gehäuse aus Unterteil (z 0..20, oben offen), Deckel (z 20..H) und vier Schrauben M3 in den Ecken der Wand, die auf dem+// Deckel aufliegen (Achse +Z). Darin eine Platine (Gruppe „Elektronik“), darunter ein Tisch als Referenz.+const MODEL = (h) => `import cadquery as cq+from soma import add_part+from soma.fasteners import Screw++base = cq.Workplane("XY").box(60, 40, 20, centered=(True, True, False)).faces(">Z").shell(-3)+lid = cq.Workplane("XY").box(60, 40, ${h - 20}, centered=(True, True, False)).translate((0, 0, 20))+screws = [Screw("ISO 4762", "M3x10", at=(x, y, ${h})) for x in (-28.5, 28.5) for y in (-18.5, 18.5)]+for s in screws:+ lid = lid.cut(s.clearance_hole())+pcb = cq.Workplane("XY").box(40, 25, 1.6, centered=(True, True, False)).translate((0, 0, 8))+table = cq.Workplane("XY").box(100, 80, 5, centered=(True, True, False)).translate((0, 0, -5))++add_part("Unterteil", base, group="Gehäuse")+add_part("Deckel", lid, group="Gehäuse", color=(0.3, 0.5, 0.85))+for i, s in enumerate(screws):+ add_part(f"Schraube {i + 1}", s, group="Gehäuse/Schrauben")+add_part("Platine", pcb, group="Elektronik", color=(0.2, 0.6, 0.3))+add_part("Tisch", table, role="reference")+`;++const near = (a, b, eps = 1e-6) => Math.abs(a - b) <= eps;+const flat = (o, eps = 1e-6) => !!o && near(o[0], 0, eps) && near(o[1], 0, eps);++try {+ app = await startApp({ name: 'explode' });+ const { ev, waitFor, domClick, page } = app;+ const shot = async (name) => {+ if (!process.env.SMOKE_SHOTS) return;+ fs.mkdirSync(path.join(APP, 'test', 'shots'), { recursive: true });+ await sleep(900);+ await app.screenshot(path.join(APP, 'test', 'shots', `${name}.png`)).catch((e) => console.log('Screenshot:', e.message));+ };+ await waitFor('Projekt und Build', () => !!window.__t && !!window.__t.project() && window.__t.status().state === 'ok' && window.__t.partCount() > 0);+ const proj = await ev(() => window.__t.project());+ fs.writeFileSync(path.join(proj.dir, 'model.py'), MODEL(24));+ await waitFor('Testmodell gebaut', () => window.__t.status().state === 'ok' && window.__t.partCount() === 8, 60000);+ await ev(() => window.__t.viewer.setView('iso'));+ await sleep(300);+ const ids = await ev(() => Object.fromEntries(window.__t.parts().map((p) => [p.name, p.id])));+ const screws = [1, 2, 3, 4].map((i) => ids[`Schraube ${i}`]);+ const ex = () => ev(() => window.__t.explode());+ const vs = () => ev(() => window.__t.viewer.explodeState());+ const settle = () => waitFor('Bewegung zu Ende', () => !window.__t.explode().animating, 5000).then(() => sleep(100));++ // 0) Achsen aus dem Build: Schrauben zeigen aus dem Material heraus (+Z), eigene Teile ohne Achse+ const input = await ev(() => window.__t.viewer.explodeParts());+ const byId = Object.fromEntries(input.map((p) => [p.id, p]));+ check('Build liefert die Achse der Normteile: Schrauben (0, 0, 1) mit Länge 13 (Kopf 3 + Schaft 10), Deckel ohne Achse',+ screws.every((id) => JSON.stringify(byId[id].axis) === '[0,0,1]' && near(byId[id].span[1] - byId[id].span[0], 13, 1e-3)) && byId[ids.Deckel].axis === null,+ JSON.stringify(byId[screws[0]]));++ // 1) Einschalten: Teile gleiten auseinander, zunächst auf 50 %+ await domClick('btn-explode');+ await settle();+ let s = await ex();+ let v = await vs();+ const off = v.offsets;+ check('„Explosion": Karte offen, Knopf gedrückt, Schieber 50 %', s.active && s.amount === 0.5 && s.shown === 0.5 && s.text.includes('50 %')+ && await ev(() => document.getElementById('btn-explode').getAttribute('aria-pressed') === 'true' && !document.getElementById('explode-card').hidden), s.text);+ check('Deckel nach oben, Unterteil nach unten, beide nur in Z (Mitten über der Mitte des Gehäuses)',+ flat(off[ids.Deckel]) && off[ids.Deckel][2] > 5 && flat(off[ids.Unterteil]) && off[ids.Unterteil][2] < -1, JSON.stringify([off[ids.Deckel], off[ids.Unterteil]]));+ const lidTop = 24 + off[ids.Deckel][2];+ check('Schrauben nur entlang ihrer Achse (+Z), gemeinsam und ganz über dem verschobenen Deckel',+ screws.every((id) => flat(off[id]) && near(off[id][2], off[screws[0]][2], 1e-6) && 14 + off[id][2] > lidTop), JSON.stringify([off[screws[0]], lidTop]));+ check('Platine (eigene Gruppe) rückt nach unten, die Referenz bleibt stehen', flat(off[ids.Platine]) && off[ids.Platine][2] < 0 && !off[ids.Tisch],+ JSON.stringify([off[ids.Platine], off[ids.Tisch]]));+ check('Gestrichelte Wege für die sieben verschobenen Teile, Hinweis nennt die Referenz', v.trails === 7 && s.moving === 7 && s.text.includes('Referenzen bleiben stehen'),+ `${v.trails} ${s.moving}`);+ check('Text für den Agenten: Explosionsansicht, nicht die Einbaulage', s.agent?.startsWith('Explosionsansicht (50 %)') && s.agent.includes('nicht die Einbaulage'), s.agent);+ await domClick('btn-explode-fit');+ await waitFor('Kamera steht', () => !window.__t.viewer.viewState().animating, 5000);+ await shot('explosion-1');++ // 2) Schieber auf 100 %: alle Verschiebungen doppelt so groß, ohne Bewegung+ const slide = (pct) => ev((x) => { const r = document.getElementById('explode-range'); r.value = x; r.dispatchEvent(new Event('input')); r.dispatchEvent(new Event('change')); }, String(pct));+ await slide(100);+ s = await ex();+ v = await vs();+ check('Schieber 100 %: Verschiebungen genau doppelt, Anzeige „100 %"', s.amount === 1 && s.shown === 1 && s.text.includes('100 %')+ && Object.keys(off).every((id) => off[id].every((x, k) => near(v.offsets[id][k], x * 2, 1e-3))), JSON.stringify(v.offsets[ids.Deckel]));+ await shot('explosion-2-voll');++ // 3) Auswahl in der Explosion: Klick auf die Deckeloberseite wählt den Deckel, der Punkt steht in Einbaulage (z = 24)+ await ev(() => window.__t.viewer.setView('top'));+ await waitFor('Kamera steht', () => !window.__t.viewer.viewState().animating, 5000);+ await sleep(200);+ const top = await ev((id) => window.__t.viewer.facesOf(id).filter((f) => f.surface === 'PLANE' && f.center && Math.abs(f.center[2] - 24) < 1e-3)+ .sort((a, b) => b.area - a.area)[0], ids.Deckel);+ // Zwischen den Schraubenlöchern, nahe der Mitte (die Mitte selbst liegt über keinem anderen Teil, trifft aber sicher den Deckel)+ const at = await ev(([id, f]) => window.__t.viewer.screenOf(id, f), [ids.Deckel, top.id]);+ await page.click(at.x, at.y);+ await waitFor('Deckel gewählt', () => window.__t.info().startsWith('Deckel'), 5000);+ const pk = await ev(() => window.__t.pick());+ check('Klick auf den verschobenen Deckel: gewählt, Punkt in Einbaulage (z = 24, nicht 24 + Verschiebung)', pk?.faceId === top.id && near(pk.point[2], 24, 0.01), JSON.stringify(pk));+ // Schräg von oben, dort verschiebt sich die Fläche im Bild. Der Deckel ist blau, die Hervorhebung orange.+ await ev(() => window.__t.viewer.setView('iso'));+ await waitFor('Kamera steht', () => !window.__t.viewer.viewState().animating, 5000);+ await sleep(500); // der Drehpunkt leuchtet nach dem Klick noch kurz in der Bildmitte auf+ const orange = (px) => px.rgb[0] > px.rgb[2] + 60;+ const blue = (px) => px.rgb[2] > px.rgb[0] + 40;+ // Nahe der hinteren Kante der Deckeloberseite: Senkt sich der Deckel auf 0 %, liegt die alte Stelle über ihm im Leeren+ const rim = (dz) => ev((p) => window.__t.viewer.screenAt(p), [0, 18, 24 + dz]);+ const was = await rim(off[ids.Deckel][2] * 2);+ const before = await ev((p) => window.__t.viewer.pixels(p.x, p.y, 2), was);+ await shot('explosion-3-auswahl');+ await slide(0);+ const moved = await rim(0);+ const after = await ev((p) => window.__t.viewer.pixels(p.x, p.y, 2), moved);+ const left = await ev((p) => window.__t.viewer.pixels(p.x, p.y, 2), was);+ check('Hervorgehobene Fläche (Orange) wandert mit dem Deckel, die alte Stelle ist nicht mehr orange',+ moved.y - was.y > 30 && orange(before) && orange(after) && !orange(left), JSON.stringify([was, moved, before.rgb, after.rgb, left.rgb]));+ await slide(75);+ const mid = await ev(([id, f]) => window.__t.viewer.screenOf(id, f), [ids.Deckel, top.id]);+ await ev(() => window.__t.viewer.select(null));+ const plain = await ev((p) => window.__t.viewer.pixels(p.x, p.y, 3), mid);+ check('Gegenprobe: ohne Auswahl ist die Stelle blau (Deckel)', blue(plain), JSON.stringify(plain.rgb));++ // 4) Ausblenden: Der Weg des ausgeblendeten Teils verschwindet, die Explosion bleibt gleich+ await ev((id) => window.__t.viewer.setVisible(id, false), ids.Platine);+ v = await vs();+ check('Platine ausgeblendet: sechs Wege, Verschiebungen unverändert', v.trails === 6 && near(v.offsets[ids.Deckel][2], off[ids.Deckel][2] * 1.5, 1e-3), String(v.trails));+ await ev((id) => window.__t.viewer.setVisible(id, true), ids.Platine);+ await domClick('btn-explode-trails');+ v = await vs();+ check('„Wege" aus: keine Linien, Knopf nicht gedrückt', v.trails === 0 && await ev(() => document.getElementById('btn-explode-trails').getAttribute('aria-pressed') === 'false'), String(v.trails));+ await domClick('btn-explode-trails');++ // 5) Schnitt dazu: Die Karten überdecken sich nicht, der Bereich des Schnitts reicht über das auseinandergezogene Modell+ await ev(() => window.__t.viewer.setView('iso'));+ await domClick('btn-section');+ await sleep(100);+ const rects = await ev(() => ['section-card', 'explode-card'].map((i) => document.getElementById(i).getBoundingClientRect().toJSON()));+ check('Schnitt und Explosion zugleich: Schnittkarte steht über der Explosionskarte', rects[0].bottom <= rects[1].top + 0.5, JSON.stringify(rects.map((r) => [r.top, r.bottom])));+ await ev(() => document.querySelector('#section-axes [data-axis="z"]').click());+ const sec = await ev(() => window.__t.section());+ check('Bereich des Schnitts in Z reicht bis zu den verschobenen Schrauben', sec.range[1] > 27 + off[screws[0]][2] - 1e-3, JSON.stringify(sec.range));+ await domClick('btn-section');++ // 6) Messen setzt sofort zusammen, Explosion schaltet umgekehrt das Messen ab+ await domClick('btn-measure');+ s = await ex();+ v = await vs();+ check('„Messen": Explosion aus, alle Teile in Einbaulage, Karte zu', !s.active && s.shown === 0 && !Object.keys(v.offsets).length && v.trails === 0+ && await ev(() => document.getElementById('explode-card').hidden && window.__t.measure().active), JSON.stringify(v.offsets).slice(0, 80));+ await domClick('btn-explode');+ await settle();+ check('„Explosion" beendet das Messen und zieht wieder auseinander (75 %, wie zuletzt eingestellt)',+ !(await ev(() => window.__t.measure().active)) && (await ex()).shown === 0.75 && Object.keys((await vs()).offsets).length === 7);++ // 7) Neuer Build: Die Explosion bleibt, die Richtungen passen zum neuen Modell (Deckel 6 mm dick)+ fs.writeFileSync(path.join(proj.dir, 'model.py'), MODEL(26));+ await waitFor('Neuer Build', () => window.__t.status().state === 'ok' && window.__t.partSize('Deckel')?.[2] === 6, 60000);+ await sleep(200);+ s = await ex();+ v = await vs();+ check('Nach dem Build: Explosion aktiv, sieben Teile verschoben, Schrauben über dem neuen Deckel', s.active && Object.keys(v.offsets).length === 7+ && screws.every((id) => v.offsets[id] && 16 + v.offsets[id][2] > 26 + v.offsets[ids.Deckel][2]), JSON.stringify([v.offsets[screws[0]], v.offsets[ids.Deckel]]));++ // 8) Schließen: Die Teile gleiten zurück in die Einbaulage+ await domClick('btn-explode-close');+ await settle();+ s = await ex();+ v = await vs();+ check('Schließen: Einbaulage, keine Wege, Knopf nicht gedrückt, kein Text für den Agenten', !s.active && s.shown === 0 && !Object.keys(v.offsets).length && v.trails === 0+ && s.agent === null && await ev(() => document.getElementById('btn-explode').getAttribute('aria-pressed') === 'false'));++ const relevant = page.errors.filter((e) => !/favicon/i.test(e));+ check('Keine Konsolenfehler im Renderer', relevant.length === 0, relevant.slice(0, 2).join(' | ').slice(0, 100));+} catch (e) {+ console.log('ABBRUCH:', e.message);+ t.fail();+}+if (app) { await app.stop(); cleanup(app.ud); }+console.log(t.fails ? `\n${t.fails} Prüfung(en) fehlgeschlagen` : '\nALLE PRÜFUNGEN BESTANDEN');+process.exit(t.fails ? 1 : 0);