Skip to content

armgit / SOMA

Public Imported from GitHub
0

Desktop app for designing parametric 3D models in CadQuery together with the coding agent of your choice

App: Ladeanzeige mit Abbrechen für die Explosion, Messen bereitet sich beim Einschalten vor

Kai-Jungsthoefelf0b70a9faec0
diff --git a/app/src/main/main.ts b/app/src/main/main.ts
index 9fb9088..2fe291d 100644
--- a/app/src/main/main.ts
+++ b/app/src/main/main.ts
@@ -122,6 +122,8 @@ function registerIpc(ctl: ProjectController): void {
ipcMain.handle('agents:detect', () => detectAgents(terminalEnv(dir())));
ipcMain.handle('measure:query', (_e, source: unknown, req: unknown) => ctl.measure(source, req));
+ ipcMain.handle('measure:start', () => ctl.measureStart());
+ ipcMain.handle('measure:prepare', (_e, source: unknown, build: unknown) => ctl.measurePrepare(source, build));
ipcMain.handle('skills:list', () => ctl.skills());
ipcMain.handle('skills:set', (_e, id: unknown, mode: unknown) => ctl.setSkill(id, mode));
ipcMain.handle('skills:configure', (_e, id: unknown, values: unknown) => ctl.configureSkill(id, values));
diff --git a/app/src/main/measure.ts b/app/src/main/measure.ts
index 2ccff50..df113f2 100644
--- a/app/src/main/measure.ts
+++ b/app/src/main/measure.ts
@@ -1,15 +1,16 @@
import { spawn, type ChildProcess } from 'node:child_process';
-import type { MeasureRequest, MeasureResponse } from '../shared/types';
+import type { MeasurePrepared, MeasureRequest, MeasureResponse } from '../shared/types';
import { pythonExe } from './paths';
const START_TIMEOUT_MS = 60_000; // cadquery zu laden dauert beim ersten Mal einige Sekunden
const REQUEST_TIMEOUT_MS = 30_000;
+const PREPARE_TIMEOUT_MS = 600_000; // große Baugruppen: Das BREP zu lesen kann Minuten dauern
interface Pending { resolve: (r: MeasureResponse) => void; timer: NodeJS.Timeout }
/**
* Langlebiger Python-Dienst pro Projekt für exakte Messungen (E24): `python -m soma serve`, JSON-Zeilen über
- * stdin/stdout. Er startet erst bei der ersten Messung (cadquery zu laden kostet Sekunden) und bleibt dann offen.
+ * stdin/stdout. Er startet erst mit dem Messmodus (cadquery zu laden kostet Sekunden) und bleibt dann offen.
* Stürzt er ab, gilt die laufende Anfrage als fehlgeschlagen, die nächste startet ihn neu. Fehler sind Ergebnisse,
* keine Ausnahmen: Die Oberfläche zeigt sie an.
*/
@@ -23,16 +24,33 @@ export class MeasureService {
constructor(private readonly cwd: string) {}
- async request(folder: string, req: MeasureRequest): Promise<MeasureResponse> {
+ request(folder: string, req: MeasureRequest): Promise<MeasureResponse> {
+ return this.send({ ...req, folder }, REQUEST_TIMEOUT_MS);
+ }
+
+ /** Den Dienst starten, ohne etwas zu messen (der Messmodus startet ihn beim Einschalten). */
+ async warm(): Promise<MeasurePrepared> {
if (this.disposed) return { ok: false, error: 'Das Modell ist geschlossen.' };
- try { await this.start(); } catch (e) { return { ok: false, error: `Der Messdienst ließ sich nicht starten: ${e instanceof Error ? e.message : String(e)}` }; }
+ try { await this.start(); return { ok: true }; }
+ catch (e) { return { ok: false, error: `Der Messdienst ließ sich nicht starten: ${e instanceof Error ? e.message : String(e)}` }; }
+ }
+
+ /** Einen Stand vorab laden. Der Dienst arbeitet der Reihe nach: Messungen danach warten, bis er geladen ist. */
+ async prepare(folder: string, build: string): Promise<MeasurePrepared> {
+ const r = await this.send({ prepare: true, build, folder }, PREPARE_TIMEOUT_MS);
+ return { ok: r.ok, error: r.error, stale: r.stale };
+ }
+
+ private async send(payload: Record<string, unknown>, timeoutMs: number): Promise<MeasureResponse> {
+ const warm = await this.warm();
+ if (!warm.ok) return warm;
const proc = this.proc;
if (!proc?.stdin) return { ok: false, error: 'Der Messdienst läuft nicht.' };
const id = ++this.seq;
return new Promise((resolve) => {
- const timer = setTimeout(() => { this.pending.delete(id); resolve({ ok: false, error: 'Der Messdienst antwortet nicht (Zeitlimit).' }); }, REQUEST_TIMEOUT_MS);
+ const timer = setTimeout(() => { this.pending.delete(id); resolve({ ok: false, error: 'Der Messdienst antwortet nicht (Zeitlimit).' }); }, timeoutMs);
this.pending.set(id, { resolve, timer });
- proc.stdin!.write(JSON.stringify({ ...req, id, folder }) + '\n');
+ proc.stdin!.write(JSON.stringify({ ...payload, id }) + '\n');
});
}
diff --git a/app/src/main/projects.ts b/app/src/main/projects.ts
index 0d496bf..cbb53c3 100644
--- a/app/src/main/projects.ts
+++ b/app/src/main/projects.ts
@@ -3,7 +3,7 @@ import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import type {
- AnimBuildResult, AnimList, ExportResult, GitLog, MeasureEntity, MeasureRequest, MeasureResponse, ModelMap, OpenResult, PreviewResult,
+ AnimBuildResult, AnimList, ExportResult, GitLog, MeasureEntity, MeasurePrepared, MeasureRequest, MeasureResponse, ModelMap, OpenResult, PreviewResult,
ProjectInfo, RenderResult, RestoreResult, ResultEntry, SaveResult, SaveState, SkillInfo, SkillResult,
} from '../shared/types';
import { affectsAnimation } from '../shared/editable';
@@ -353,11 +353,8 @@ export class ProjectController {
*/
async measure(source: unknown, req: unknown): Promise<MeasureResponse> {
const s = this.need();
- let folder: string;
- const hash = (source as { preview?: unknown } | null)?.preview;
- if (source === 'live') folder = path.join(s.dir, '.soma');
- else if (typeof hash === 'string' && /^[0-9a-f]{7,40}$/.test(hash)) folder = path.join(previewsDir(), s.id, hash);
- else return { ok: false, error: 'Unbekannte Quelle für die Messung.' };
+ const folder = this.measureFolder(s, source);
+ if (!folder) return { ok: false, error: 'Unbekannte Quelle für die Messung.' };
const r = req as { build?: unknown; a?: unknown; b?: unknown } | null;
const ent = (v: unknown): MeasureEntity | null => {
const e = v as { part?: unknown; kind?: unknown; id?: unknown; point?: unknown; check?: unknown } | null;
@@ -371,6 +368,27 @@ export class ProjectController {
return s.measure.request(folder, clean);
}
+ /** Ordner des gemessenen Stands, den bestimmt der Hauptprozess. Unbekannte Quelle: null. */
+ private measureFolder(s: Session, source: unknown): string | null {
+ const hash = (source as { preview?: unknown } | null)?.preview;
+ if (source === 'live') return path.join(s.dir, '.soma');
+ if (typeof hash === 'string' && /^[0-9a-f]{7,40}$/.test(hash)) return path.join(previewsDir(), s.id, hash);
+ return null;
+ }
+
+ /** Messdienst vorab starten, sobald der Nutzer den Messmodus einschaltet. */
+ async measureStart(): Promise<MeasurePrepared> {
+ return this.need().measure.warm();
+ }
+
+ /** Den angezeigten Stand vorab in den Messdienst laden. */
+ async measurePrepare(source: unknown, build: unknown): Promise<MeasurePrepared> {
+ const s = this.need();
+ const folder = this.measureFolder(s, source);
+ if (!folder || typeof build !== 'string') return { ok: false, error: 'Ungültige Messanfrage.' };
+ return s.measure.prepare(folder, build);
+ }
+
async restore(hash: string): Promise<RestoreResult> {
const s = this.need();
const commit = (await s.git.log()).find((c) => c.hash === hash);
diff --git a/app/src/preload/preload.ts b/app/src/preload/preload.ts
index 8a438f5..6c302a6 100644
--- a/app/src/preload/preload.ts
+++ b/app/src/preload/preload.ts
@@ -60,7 +60,11 @@ const api: SomaApi = {
onExit: (cb) => { ipcRenderer.on('term:exit', (_e, id, code) => cb(id, code)); },
},
agents: { detect: () => ipcRenderer.invoke('agents:detect') },
- measure: { query: (source, req) => ipcRenderer.invoke('measure:query', source, req) },
+ measure: {
+ query: (source, req) => ipcRenderer.invoke('measure:query', source, req),
+ start: () => ipcRenderer.invoke('measure:start'),
+ prepare: (source, build) => ipcRenderer.invoke('measure:prepare', source, build),
+ },
skills: {
list: () => ipcRenderer.invoke('skills:list'),
set: (id, mode) => ipcRenderer.invoke('skills:set', id, mode),
diff --git a/app/src/renderer/busy.ts b/app/src/renderer/busy.ts
new file mode 100644
index 0000000..2cfc4d3
--- /dev/null
+++ b/app/src/renderer/busy.ts
@@ -0,0 +1,96 @@
+import { $ } from './ui';
+
+/** Erst nach dieser Zeit erscheint die Anzeige: Was schneller fertig ist, soll nicht aufblitzen. */
+const SHOW_AFTER_MS = 200;
+
+export interface BusyHandle {
+ /** Anteil 0 bis 1, null: unbestimmt (der Balken läuft durch). */
+ progress(f: number | null): void;
+ /** Zweite Zeile, etwa der laufende Schritt. */
+ detail(text: string): void;
+ /** Schließen. Gehört die Anzeige inzwischen einem anderen, bleibt sie stehen. */
+ close(): void;
+}
+
+/**
+ * Ladeanzeige über dem Viewer, solange ein Werkzeug sich vorbereitet (Explosion: Strahltest bei großen Baugruppen). Sie deckt
+ * den Viewer ab, Klicks ins Modell kämen sonst vor dem Ergebnis an. „Abbrechen“ und Escape beenden das Werkzeug. Es gibt immer
+ * nur eine: Wer neu anfängt, übernimmt sie. Messen zeigt seine Vorbereitung in der eigenen Karte, dort darf man schon klicken.
+ */
+export class Busy {
+ private owner = 0;
+ private cancel: (() => void) | null = null;
+ private timer: ReturnType<typeof setTimeout> | undefined;
+ private t0 = 0;
+ private tick: ReturnType<typeof setInterval> | undefined;
+ private root = $('viewer-busy');
+ private title = $('viewer-busy-title');
+ private sub = $('viewer-busy-detail');
+ private time = $('viewer-busy-time');
+ private bar = $('viewer-busy-bar');
+ private fill = $('viewer-busy-fill');
+
+ constructor() {
+ $('btn-busy-cancel').addEventListener('click', () => this.abort());
+ window.addEventListener('keydown', (e) => {
+ if (this.root.hidden || e.key !== 'Escape' || e.defaultPrevented) return;
+ const t = e.target as HTMLElement | null;
+ if (t?.closest?.('#terminals, #code-view, input, textarea, .menu')) return;
+ e.preventDefault();
+ this.abort();
+ }, true); // vor den Werkzeugen: Escape bricht das Laden ab, nicht mehr
+ }
+
+ /** `cancel`: was „Abbrechen“ tut (das Werkzeug beenden). */
+ show(title: string, cancel: () => void): BusyHandle {
+ const id = ++this.owner;
+ this.cancel = cancel;
+ this.title.textContent = title;
+ this.sub.textContent = '';
+ this.time.textContent = '';
+ this.setProgress(null);
+ clearTimeout(this.timer);
+ clearInterval(this.tick);
+ this.root.hidden = true;
+ this.t0 = performance.now();
+ this.timer = setTimeout(() => {
+ if (id !== this.owner) return;
+ this.root.hidden = false;
+ // Sekunden mitzählen: Auch ohne Fortschritt sieht man, dass noch etwas geschieht
+ this.tick = setInterval(() => { this.time.textContent = `${Math.round((performance.now() - this.t0) / 1000)} s`; }, 1000);
+ }, SHOW_AFTER_MS);
+ const mine = () => id === this.owner;
+ return {
+ progress: (f) => { if (mine()) this.setProgress(f); },
+ detail: (text) => { if (mine()) this.sub.textContent = text; },
+ close: () => { if (mine()) this.hide(); },
+ };
+ }
+
+ get visible(): boolean { return !this.root.hidden; }
+ /** Für Tests: Titel und Zeile darunter, null wenn nichts lädt. */
+ state(): { title: string; detail: string; progress: number | null } | null {
+ if (!this.cancel) return null;
+ const w = this.fill.style.width;
+ return { title: this.title.textContent ?? '', detail: this.sub.textContent ?? '', progress: this.bar.classList.contains('indet') ? null : parseFloat(w) / 100 };
+ }
+
+ private setProgress(f: number | null): void {
+ this.bar.classList.toggle('indet', f === null);
+ this.fill.style.width = f === null ? '' : `${Math.round(Math.min(1, Math.max(0, f)) * 100)}%`;
+ }
+
+ private abort(): void {
+ const c = this.cancel;
+ this.hide();
+ c?.();
+ }
+
+ private hide(): void {
+ this.owner++;
+ this.cancel = null;
+ clearTimeout(this.timer);
+ clearInterval(this.tick);
+ this.root.hidden = true;
+ }
+}
diff --git a/app/src/renderer/explodetool.ts b/app/src/renderer/explodetool.ts
index cb1aa82..d0d5cc6 100644
--- a/app/src/renderer/explodetool.ts
+++ b/app/src/renderer/explodetool.ts
@@ -1,3 +1,4 @@
+import type { Busy } from './busy';
import { icon } from './icons';
import type { BlockMap, ExplodePart, Viewer } from './viewer';
@@ -24,6 +25,8 @@ interface Ui {
}
interface Deps {
viewer: Viewer;
+ /** Ladeanzeige, solange die Analyse rechnet (große Baugruppen: Sekunden). */
+ busy: Busy;
/** 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. */
@@ -469,6 +472,8 @@ export class ExplodeTool {
private trails = true;
/** Laufende Bewegung. Beim Abspielen mit Ziel, damit ein neues Tempo von der aktuellen Lage aus weiterläuft. */
private anim: { stop(): void; goal?: { target: number; play: boolean } } | null = null;
+ /** Laufende Analyse (Strahltest), abbrechbar. */
+ private loading: AbortController | null = null;
private ui: Required<Ui>;
constructor(ui: Ui, private deps: Deps) {
@@ -510,11 +515,25 @@ export class ExplodeTool {
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(); }
this.stepPos = null;
+ if (on) {
+ this.deps.beforeOn();
+ if (!this.analysis) {
+ // Die Karte erscheint erst mit dem Ergebnis, bis dahin zeigt die Ladeanzeige den Fortschritt
+ this.ui.card.hidden = true;
+ void this.prepare(() => { this.compute(); this.ui.card.hidden = false; this.goTo(true, animate); });
+ return;
+ }
+ this.compute();
+ } else this.cancelLoad();
+ this.ui.card.hidden = !on;
}
+ if (this.loading) return; // noch keine Analyse, prepare() fährt danach auseinander
+ this.goTo(on, animate);
+ }
+
+ private goTo(on: boolean, animate: boolean): void {
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(); }
@@ -524,10 +543,55 @@ export class ExplodeTool {
/** Neues Modell (Build oder anderer Stand): neu analysieren, die Explosion bleibt so weit, wie sie war. */
refresh(): void {
this.analysis = null;
- if (!this.active && this.shown <= 0) { this.plan = null; return; } // erst beim Einschalten rechnen
- this.compute();
- if (this.shown > 0) this.show(this.shown);
- this.render();
+ this.cancelLoad();
+ if (!this.active) { // erst beim Einschalten rechnen. Läuft noch das Zusammenfahren: gleich in Einbaulage
+ if (this.shown > 0) { this.stopAnim(); this.show(0); }
+ this.plan = null;
+ return;
+ }
+ if (this.anim?.goal) this.stopAnim(); // ein laufender Schritt gehört zum alten Plan
+ void this.prepare(() => {
+ this.compute();
+ if (this.shown > 0) this.show(this.shown);
+ this.render();
+ this.deps.settled();
+ });
+ }
+
+ /**
+ * Strahltest im Hintergrund mit Ladeanzeige, danach `then`. Abbrechen (Knopf, Escape) beendet die Explosion. Ein neuer Aufruf
+ * oder cancelLoad() verwirft den laufenden, dessen `then` kommt dann nicht mehr.
+ */
+ private async prepare(then: () => void): Promise<void> {
+ this.cancelLoad();
+ const ctl = new AbortController();
+ this.loading = ctl;
+ const { viewer } = this.deps;
+ const view = this.deps.busy.show('Explosion wird vorbereitet', () => this.setActive(false, false));
+ try {
+ // Strahltest und Hüllquader in Einbaulage
+ if (this.shown > 0) viewer.setOffsets(null);
+ const own = viewer.explodeParts().filter((p) => p.role !== 'reference');
+ const size = diagonal(own);
+ const t0 = performance.now();
+ const { dirs, opp } = directions(own);
+ view.detail(`${own.length} Bauteile: Was steht wem im Weg?`);
+ const block = await viewer.explodeRays(own.map((p) => p.id), dirs, opp,
+ { eps: Math.max(EPS_MIN, EPS * size), touch: Math.max(TOUCH_MIN, TOUCH * size), samples: SAMPLES },
+ { signal: ctl.signal, progress: (f) => view.progress(f) });
+ if (!block || this.loading !== ctl) return;
+ this.analysis = { dirs, opp, block, ms: performance.now() - t0 };
+ this.loading = null;
+ then();
+ } finally {
+ if (this.loading === ctl) this.loading = null;
+ view.close();
+ }
+ }
+
+ private cancelLoad(): void {
+ this.loading?.abort();
+ this.loading = null;
}
/** Beschreibung für den Agenten, etwa beim Markieren. Ohne Explosion null. */
@@ -537,23 +601,18 @@ export class ExplodeTool {
return `Explosionsansicht (${Math.round(this.shown * 100)} %${step}): Die Bauteile sind nur zur Darstellung auseinandergezogen, ihre Lage im Bild ist nicht die Einbaulage`;
}
+ /** Plan und Lagen aus der Analyse (prepare() hat sie gerechnet). */
private compute(): void {
const { viewer } = this.deps;
+ if (!this.analysis) return;
// Ein laufender Schritt gehört zum alten Plan (seine Nummern stimmen nicht mehr)
if (this.anim?.goal) this.stopAnim();
- // Strahltest und Hüllquader in Einbaulage. Wer danach etwas zeigen will, ruft show() wieder auf.
+ // Hüllquader in Einbaulage. Wer danach etwas zeigen will, ruft show() wieder auf.
if (this.shown > 0) viewer.setOffsets(null);
const parts = viewer.explodeParts();
const own = parts.filter((p) => p.role !== 'reference');
const size = diagonal(own);
this.axis = autoAxis(parts);
- if (!this.analysis) {
- const t0 = performance.now();
- const { dirs, opp } = directions(own);
- const block = viewer.explodeRays(own.map((p) => p.id), dirs, opp,
- { eps: Math.max(EPS_MIN, EPS * size), touch: Math.max(TOUCH_MIN, TOUCH * size), samples: SAMPLES });
- this.analysis = { dirs, opp, block, ms: performance.now() - t0 };
- }
const { dirs, opp, block } = this.analysis;
this.plan = disassemble(own, dirs, opp, block, AXES[this.axis]);
this.near = layout(own, this.plan, GAP * size);
@@ -820,7 +879,8 @@ export class ExplodeTool {
const plan = this.plan;
return {
active: this.active, amount: this.amount, shown: this.shown, trails: this.trails, axis: this.axis,
- moving: this.moving, forced: this.forced, animating: !!this.anim, analysisMs: this.analysis ? Math.round(this.analysis.ms) : null,
+ // animating auch während der Analyse: Tests warten so auf die fertige Lage
+ moving: this.moving, forced: this.forced, animating: !!this.anim || !!this.loading, loading: !!this.loading, analysisMs: this.analysis ? Math.round(this.analysis.ms) : null,
base: plan?.base ?? null,
steps: plan ? flatSteps(plan) : {},
spreads: vec(this.near.offsets), far: vec(this.far.offsets),
diff --git a/app/src/renderer/index.html b/app/src/renderer/index.html
index 9fb54f4..9898a1a 100644
--- a/app/src/renderer/index.html
+++ b/app/src/renderer/index.html
@@ -92,6 +92,16 @@
<section id="viewer" aria-label="3D-Ansicht">
<div id="viewer-msg"></div>
+ <!-- Ladeanzeige (busy.ts): Die Explosion rechnet bei großen Baugruppen einige Sekunden -->
+ <div id="viewer-busy" class="vbusy" hidden>
+ <div class="float vb-card" role="status" aria-live="polite">
+ <div class="vb-hd"><span class="spin"><i data-icon="spin" data-size="16" data-stroke="2.4"></i></span><b id="viewer-busy-title"></b><span class="grow"></span><span id="viewer-busy-time" class="c3 small"></span></div>
+ <div id="viewer-busy-detail" class="vb-sub"></div>
+ <div id="viewer-busy-bar" class="vb-bar indet"><div id="viewer-busy-fill"></div></div>
+ <div class="sc-actions"><button id="btn-busy-cancel" class="btn sm" title="Vorbereitung abbrechen und das Werkzeug beenden (Escape)">Abbrechen</button></div>
+ </div>
+ </div>
+
<!-- Oben links: was der Viewer zeigt (Modell oder ein Ergebnis des Agenten). In der Mitte die Werkzeuge. -->
<div id="vtop" class="vtop">
<div id="view-switch" class="float switcher">
diff --git a/app/src/renderer/main.ts b/app/src/renderer/main.ts
index cd63d7e..5903630 100644
--- a/app/src/renderer/main.ts
+++ b/app/src/renderer/main.ts
@@ -2,6 +2,7 @@ import { affectsBuild } from '../shared/editable';
import type { AgentInfo, AnimEntry, BuildStatus, ExportResult, FileNode, ModelMap, PartMap, PreviewResult, ProjectInfo, ResultEntry, SaveState } from '../shared/types';
import { CodePanel, codeRows, isPdf, type Mark } from './code';
import { AnimTool } from './animtool';
+import { Busy } from './busy';
import { DRAG_FILE, FileTree, IMAGE_EXT, TEXT_EXT, VIDEO_EXT } from './filetree';
import { hydrateIcons, icon } from './icons';
import { Markup } from './markup';
@@ -384,6 +385,8 @@ const sectionTool = new SectionTool({
// ---- Explosionsansicht (E56) ----------------------------------------------------------------------------------------
+/** Ladeanzeige über dem Viewer, solange die Explosion rechnet. */
+const busy = new Busy();
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'),
@@ -392,6 +395,7 @@ const explodeTool = new ExplodeTool({
step: $('explode-step'), send: $<HTMLButtonElement>('btn-explode-agent'),
}, {
viewer,
+ busy,
insert: (t) => insertToAgent(t),
beforeOn: () => { if (measureTool.isActive) measureTool.setActive(false); },
settled: () => sectionTool.refresh(), // der Bereich des Schiebers folgt den verschobenen Bauteilen
@@ -1291,6 +1295,7 @@ if (api.testMode) {
measure: () => measureTool.state(),
section: () => sectionTool.state(),
explode: () => explodeTool.state(),
+ busy: () => busy.state(),
anim: () => animTool.state(),
animSeek: (t: number) => animTool.testSeek(t),
animRefresh: () => animTool.refresh(),
diff --git a/app/src/renderer/measuretool.ts b/app/src/renderer/measuretool.ts
index ece5d6e..71e12c5 100644
--- a/app/src/renderer/measuretool.ts
+++ b/app/src/renderer/measuretool.ts
@@ -1,4 +1,5 @@
import type { MeasureInfo, MeasureResponse, MeasureResult, MeasureSource, MeasureSpan, PartMap } from '../shared/types';
+import { icon } from './icons';
import { el } from './ui';
import type { MeasureMarks, ProbeHit, Viewer } from './viewer';
@@ -63,6 +64,15 @@ export class MeasureTool {
private warm = false;
/** Einmaliger Hinweis, etwa nach einem Klick auf die Schnittfläche. Verschwindet beim nächsten Klick. */
private note = '';
+ /**
+ * Vorbereitung beim Einschalten: Messdienst starten, den Stand laden (große Baugruppen: Sekunden). Klicks sind schon
+ * möglich, ihre Messung wartet darauf. `phase`: was gerade geschieht, leer wenn bereit.
+ */
+ private prep: Promise<void> | null = null;
+ private prepSeq = 0;
+ private phase = '';
+ private prepT0 = 0;
+ private prepTick: ReturnType<typeof setInterval> | undefined;
constructor(private ui: Ui, private deps: Deps) {
ui.button.addEventListener('click', () => this.setActive(!this.active));
@@ -91,11 +101,53 @@ export class MeasureTool {
this.ui.viewerEl.classList.toggle('measuring', on);
this.deps.viewer.setMode(on ? 'measure' : 'select');
this.clear();
+ if (on) this.prepare(); else this.endPrepare();
this.render();
}
- /** Neuer Build oder anderer Stand: Die IDs der Flächen und Kanten gelten nicht mehr. */
- reset(): void { this.clear(); this.render(); }
+ /** Neuer Build oder anderer Stand: Die IDs der Flächen und Kanten gelten nicht mehr, den neuen Stand vorab laden. */
+ reset(): void {
+ this.clear();
+ if (this.active) this.prepare();
+ this.render();
+ }
+
+ private prepare(): void {
+ const build = this.deps.build();
+ this.endPrepare();
+ if (!build) return; // ohne Geometrie meldet der erste Klick, was fehlt
+ const seq = this.prepSeq;
+ const source = this.deps.source();
+ const n = this.deps.viewer.partList().length;
+ this.prepT0 = performance.now();
+ // Sekunden mitzählen, nur die Zahl: Neu zeichnen ließe den laufenden Balken jedes Mal von vorn beginnen
+ this.prepTick = setInterval(() => { const t = this.ui.body.querySelector('.mc-load-time'); if (t) t.textContent = this.prepSeconds(); }, 1000);
+ this.phase = 'Messdienst startet …';
+ this.prep = (async () => {
+ // Läuft der Dienst schon, ist start() gleich fertig
+ let r = await window.soma.measure.start().catch((e: unknown) => ({ ok: false, error: String(e), stale: false }));
+ if (seq !== this.prepSeq) return;
+ if (r.ok) {
+ this.phase = `Geometrie wird geladen (${n} ${n === 1 ? 'Bauteil' : 'Bauteile'}) …`;
+ this.render();
+ r = await window.soma.measure.prepare(source, build).catch((e: unknown) => ({ ok: false, error: String(e), stale: false }));
+ if (seq !== this.prepSeq) return;
+ }
+ // Ein veralteter Stand ist kein Fehler: Der neue Build ruft reset() und lädt selbst
+ if (r.ok) this.warm = true;
+ else if (!r.stale && !this.a) this.error = r.error ?? 'Der Messdienst ließ sich nicht vorbereiten.';
+ this.endPrepare();
+ this.render();
+ })();
+ }
+
+ /** Vorbereitung beenden oder verwerfen (der Dienst lädt im Hintergrund zu Ende, das schadet nicht). */
+ private endPrepare(): void {
+ this.prepSeq++;
+ this.prep = null;
+ this.phase = '';
+ clearInterval(this.prepTick);
+ }
private clear(): void {
this.a = this.b = null;
@@ -127,6 +179,7 @@ export class MeasureTool {
const seq = ++this.seq;
this.busy = true;
this.render();
+ if (this.prep) { await this.prep; if (seq !== this.seq) return; } // erst den Stand fertig laden, sonst läuft das Zeitlimit
const ent = (x: ProbeHit) => ({ part: x.partId, kind: x.kind, id: x.id, point: x.point, check: x.size ?? undefined });
let r: MeasureResponse;
try { r = await window.soma.measure.query(this.deps.source(), { build, a: ent(this.a!), ...(this.b ? { b: ent(this.b) } : {}) }); }
@@ -195,9 +248,10 @@ export class MeasureTool {
if (!this.active) return;
const rows: HTMLElement[] = [];
const hint = (t: string) => el('div', { className: 'mc-hint', textContent: t });
- if (!this.a) rows.push(hint('Klick auf einen Punkt, eine Kante oder eine Fläche. Ein zweiter Klick misst Abstand und Winkel zum ersten.'));
- else if (this.busy) rows.push(hint(this.warm ? 'Messe …' : 'Messe … Beim ersten Mal startet der Messdienst, das dauert einige Sekunden.'));
- else if (this.error) rows.push(el('div', { className: 'mc-err', textContent: this.error }));
+ if (this.phase) rows.push(this.loadingRow());
+ if (this.error && !this.busy) rows.push(el('div', { className: 'mc-err', textContent: this.error }));
+ else if (!this.a) rows.push(hint('Klick auf einen Punkt, eine Kante oder eine Fläche. Ein zweiter Klick misst Abstand und Winkel zum ersten.'));
+ else if (this.busy) rows.push(hint(this.phase ? 'Gemessen wird, sobald die Geometrie geladen ist.' : this.warm ? 'Messe …' : 'Messe … Beim ersten Mal startet der Messdienst, das dauert einige Sekunden.'));
else if (this.result && !this.result.b) {
rows.push(...this.entityRows(this.result.a, true));
rows.push(hint('Zweites Element anklicken für Abstand und Winkel.'));
@@ -222,6 +276,19 @@ export class MeasureTool {
agent.disabled = !this.result;
}
+ /** Was die Vorbereitung gerade tut, mit Sekunden und laufendem Balken. */
+ private loadingRow(): HTMLElement {
+ return el('div', { className: 'mc-load' },
+ el('div', { className: 'mc-load-hd' }, el('span', { className: 'spin' }, icon('spin', 14, 2.4)), el('span', { className: 'grow', textContent: this.phase }),
+ el('span', { className: 'c3 mc-load-time', textContent: this.prepSeconds() })),
+ el('div', { className: 'vb-bar indet' }, el('div')));
+ }
+
+ private prepSeconds(): string {
+ const s = Math.round((performance.now() - this.prepT0) / 1000);
+ return s ? `${s} s` : '';
+ }
+
private row(label: string, value: string): HTMLElement {
return el('div', { className: 'mc-row' }, el('span', { textContent: label }), el('span', { className: 'v', textContent: value }));
}
@@ -284,6 +351,6 @@ export class MeasureTool {
// ---- Prüfhilfe (nur Tests) ------------------------------------------------------------------------------------
state() {
- return { active: this.active, a: this.a, b: this.b, busy: this.busy, error: this.error, result: this.result, text: this.ui.body.textContent, agentText: this.agentText() };
+ return { active: this.active, a: this.a, b: this.b, busy: this.busy, preparing: !!this.prep, phase: this.phase, error: this.error, result: this.result, text: this.ui.body.textContent, agentText: this.agentText() };
}
}
diff --git a/app/src/renderer/style.css b/app/src/renderer/style.css
index 76e29cb..a7e9992 100644
--- a/app/src/renderer/style.css
+++ b/app/src/renderer/style.css
@@ -327,6 +327,16 @@ code { font-family:var(--mono); font-size:.95em; }
#viewer.preview::after { content:''; position:absolute; inset:0; border:2px solid var(--vio); pointer-events:none; z-index:6; }
#viewer-msg { position:absolute; left:50%; top:50%; transform:translate(-50%,-50%); color:var(--tx2); pointer-events:none; white-space:pre-wrap; text-align:center; z-index:1; max-width:70%; }
#viewer-msg.error { color:var(--err); }
+/* Ladeanzeige (busy.ts): deckt den Viewer ab, bis die Explosion bereit ist. Unter Banner und Markierung */
+.vbusy { position:absolute; inset:0; z-index:5; display:flex; align-items:center; justify-content:center; background:rgba(18,20,23,.45); }
+.vb-card { position:static; width:min(340px, calc(100% - 32px)); }
+.vb-hd { display:flex; align-items:center; gap:9px; padding:12px 14px 4px; }
+.vb-hd b { font-size:14px; }
+.vb-sub { padding:0 14px; min-height:18px; font-size:12px; color:var(--tx2); overflow-wrap:anywhere; }
+.vb-bar { position:relative; height:4px; margin:10px 14px 0; border-radius:2px; background:var(--s3); overflow:hidden; }
+.vb-bar > div { height:100%; width:0; background:var(--acc); transition:width .15s; }
+.vb-bar.indet > div { width:35%; position:absolute; animation:vb-run 1.2s ease-in-out infinite; transition:none; }
+@keyframes vb-run { from { left:-35%; } to { left:100%; } }
.float { position:absolute; z-index:2; background:rgba(24,27,31,.95); border:1px solid var(--line2); border-radius:10px; box-shadow:var(--shadow); }
/* Bauteile (Entwurf 2): Baum in der Seitenleiste. Kompakte Zeilen, die Knöpfe erscheinen beim Überfahren
@@ -403,6 +413,10 @@ code { font-family:var(--mono); font-size:.95em; }
.mc-ico { color:var(--acc-tx); display:flex; }
.mc-body { padding:0 0 4px; }
.mc-hint { padding:2px 14px 6px; font-size:12px; color:var(--tx3); }
+/* Vorbereitung des Messens (Messdienst, Geometrie): Zeile mit Sekunden und laufendem Balken */
+.mc-load { padding:2px 0 10px; }
+.mc-load-hd { display:flex; align-items:center; gap:8px; padding:0 14px; font-size:12px; color:var(--tx2); }
+.mc-load .vb-bar { margin-top:8px; }
.mc-err { margin:2px 12px 6px; padding:8px 10px; border-radius:6px; background:var(--err-tint); color:#ffc4c0; font-size:12px; }
.mc-title { display:flex; align-items:baseline; gap:8px; padding:2px 14px 6px; min-width:0; }
.mc-title b { font-size:13px; white-space:nowrap; }
diff --git a/app/src/renderer/viewer.ts b/app/src/renderer/viewer.ts
index 0680f9c..6f6756f 100644
--- a/app/src/renderer/viewer.ts
+++ b/app/src/renderer/viewer.ts
@@ -84,6 +84,8 @@ export interface RayHit { dist: number; touch: number; inside: number }
/** Je Richtung: Bauteil → (Bauteil, das ihm in dieser Richtung im Weg steht → Treffer). */
export type BlockMap = Map<string, Map<string, RayHit>>[];
+/** So lange rechnet der Strahltest am Stück, bevor er die Oberfläche wieder zeichnen lässt. */
+const YIELD_MS = 30;
/** Punkte je Dreieck für den Strahltest (baryzentrisch), wichtigste zuerst: Mitte, nahe den Ecken, nahe den Kanten. */
const SAMPLE_PATTERN = [[1 / 3, 1 / 3, 1 / 3], [0.7, 0.15, 0.15], [0.15, 0.7, 0.15], [0.15, 0.15, 0.7],
[0.425, 0.425, 0.15], [0.15, 0.425, 0.425], [0.425, 0.15, 0.425]];
@@ -1465,8 +1467,21 @@ export class Viewer {
* zählen nicht) gehen Strahlen in jede Richtung, gegen alle Bauteile zugleich (BVH). Trifft ein Strahl von P aus Q im Abstand t,
* stößt P in dieser Richtung nach t gegen Q, und Q stieße in der Gegenrichtung gegen P. Treffer unter `touch` zählen als
* Berührung: Dort liegt P an. `opp[i]` ist die Gegenrichtung von `dirs[i]`. Höchstens etwa `samples` Punkte je Bauteil.
+ * Bei großen Baugruppen dauert das Sekunden: Die Rechnung gibt regelmäßig die Oberfläche frei, meldet den Fortschritt (0 bis 1)
+ * und hört auf, sobald `signal` abbricht (Ergebnis dann null).
*/
- explodeRays(ids: string[], dirs: number[][], opp: number[], opts: { eps: number; touch: number; samples: number }): BlockMap {
+ async explodeRays(ids: string[], dirs: number[][], opp: number[], opts: { eps: number; touch: number; samples: number },
+ ctl: { signal?: AbortSignal; progress?: (f: number) => void } = {}): Promise<BlockMap | null> {
+ let last = performance.now();
+ // Freigeben, damit die Ladeanzeige zeichnet und „Abbrechen“ ankommt. false: abgebrochen. Nur aufrufen, wenn `due()`:
+ // Ein await je Strahlpunkt kostete merklich Zeit
+ const due = () => performance.now() - last >= YIELD_MS;
+ const breathe = async (f: number): Promise<boolean> => {
+ ctl.progress?.(f);
+ await new Promise((r) => setTimeout(r, 0));
+ last = performance.now();
+ return !ctl.signal?.aborted;
+ };
const chunks = ids.flatMap((id) => { const p = this.parts.get(id); return p ? [{ id, p, w: this.worldOf(p) }] : []; });
// Dreiecke aller Teile in Einbaulage hintereinander. Die BVH ordnet nur den Index um, die Ecken bleiben: Über ihren
// Bereich findet ein Treffer sein Bauteil.
@@ -1495,12 +1510,17 @@ export class Viewer {
};
const out: BlockMap = dirs.map(() => new Map());
if (!ni) return out;
+ // Vor dem Aufbau der BVH einmal zeichnen lassen, der dauert bei großen Netzen selbst spürbar
+ if (!await breathe(0)) return null;
// Die BVH sortiert den Index beim Aufbau um: Die Punkte je Bauteil kommen aus einer Kopie
const tri = index.slice();
const g = new THREE.BufferGeometry();
g.setAttribute('position', new THREE.BufferAttribute(pos, 3));
g.setIndex(new THREE.BufferAttribute(index, 1));
const bvh = new MeshBVH(g);
+ // Für den Fortschritt: Zahl der Dreiecke, von denen Strahlen ausgehen
+ const total = range.reduce((n, r) => { const t = (r.i1 - r.i0) / 3; return n + (t ? Math.ceil(t / Math.max(1, Math.ceil(t / opts.samples))) : 0); }, 0) || 1;
+ let done = 0;
const note = (m: Map<string, Map<string, RayHit>>, a: string, b: string, dist: number, touch: number, inside: number) => {
let row = m.get(a);
if (!row) { row = new Map(); m.set(a, row); }
@@ -1519,6 +1539,8 @@ export class Viewer {
const per = Math.max(1, Math.min(SAMPLE_PATTERN.length, Math.floor(opts.samples / tris)));
const stride = Math.max(1, Math.ceil(tris / opts.samples));
for (let t = 0; t < tris; t += stride) {
+ if (due() && !await breathe(done / total)) { g.dispose(); return null; }
+ done++;
const k = r.i0 + t * 3;
A.fromArray(pos, tri[k] * 3); B.fromArray(pos, tri[k + 1] * 3); C.fromArray(pos, tri[k + 2] * 3);
// Der Mesher legt die Dreiecke so, dass die Normale nach außen zeigt (gespiegelte Flächen umgedreht)
diff --git a/app/src/shared/types.ts b/app/src/shared/types.ts
index 98934c1..57a0aa5 100644
--- a/app/src/shared/types.ts
+++ b/app/src/shared/types.ts
@@ -92,6 +92,7 @@ export interface MeasurePair {
export interface MeasureResult { build: string; a: MeasureInfo; b?: MeasureInfo; pair?: MeasurePair }
/** `stale`: Die Anfrage gehört zu einem älteren Build, die Auswahl ist neu zu treffen. */
export interface MeasureResponse { ok: boolean; result?: MeasureResult; error?: string; stale?: boolean }
+export interface MeasurePrepared { ok: boolean; error?: string; stale?: boolean }
/** Wert einer Einstellung eines Skills: Zahl oder gewählter Eintrag. */
export type SkillValue = number | string;
@@ -286,7 +287,13 @@ export interface SomaApi {
};
agents: { detect(): Promise<AgentInfo[]> };
/** Exakte Messung über den Python-Dienst (E9, E24). */
- measure: { query(source: MeasureSource, req: MeasureRequest): Promise<MeasureResponse> };
+ measure: {
+ query(source: MeasureSource, req: MeasureRequest): Promise<MeasureResponse>;
+ /** Den Messdienst starten (cadquery laden), noch ohne Modell. Dauert beim ersten Mal einige Sekunden. */
+ start(): Promise<MeasurePrepared>;
+ /** Den Stand vorab in den Messdienst laden, damit der erste Klick nicht darauf wartet (große Baugruppen: Sekunden). */
+ prepare(source: MeasureSource, build: string): Promise<MeasurePrepared>;
+ };
/** Skills des offenen Modells (E17): auflisten, Stufe wählen (E55). */
skills: {
list(): Promise<SkillInfo[]>;
diff --git a/app/test/explode.mjs b/app/test/explode.mjs
index 4e4af6b..d4b0b2d 100644
--- a/app/test/explode.mjs
+++ b/app/test/explode.mjs
@@ -91,6 +91,20 @@ try {
screws.every((id) => JSON.stringify(byId[id].axis) === '[0,0,1]') && side.every((id) => JSON.stringify(byId[id].axis) === '[1,0,0]')
&& JSON.stringify(byId[ids.Mutter].axis) === '[0,0,1]' && byId[ids.Deckel].axis === null, JSON.stringify(byId[ids.Mutter].axis));
+ // 0b) Abbrechen während der Analyse (große Baugruppen rechnen Sekunden): Explosion aus, nichts verschoben, Karte zu
+ const cancelled = await ev(() => {
+ document.getElementById('btn-explode').click();
+ const during = { loading: window.__t.explode().loading, busy: window.__t.busy() };
+ document.getElementById('btn-busy-cancel').click();
+ return { during, after: window.__t.explode(), busy: window.__t.busy(), card: document.getElementById('explode-card').hidden };
+ });
+ await sleep(300);
+ check('Abbrechen während der Analyse: Explosion aus, Karte zu, Ladeanzeige weg, nichts verschoben',
+ cancelled.during.loading && cancelled.during.busy?.title === 'Explosion wird vorbereitet' && !cancelled.after.active && !cancelled.after.loading
+ && cancelled.card && cancelled.busy === null && !(await ev(() => window.__t.explode())).active && !Object.keys((await vs()).offsets).length
+ && await ev(() => document.getElementById('viewer-busy').hidden && document.getElementById('btn-explode').getAttribute('aria-pressed') === 'false'),
+ JSON.stringify(cancelled).slice(0, 160));
+
// 1) Einschalten: Demontage-Analyse, zunächst auf 50 %
await domClick('btn-explode');
await settle();
@@ -345,7 +359,7 @@ try {
// 7) Neuer Build: Die Explosion bleibt, die Analyse läuft neu (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);
+ await settle(); // die Analyse des neuen Stands läuft im Hintergrund
s = await ex();
vo = (await vs()).offsets;
check('Nach dem Build: Explosion aktiv, zwölf Teile verschoben, Schrauben über dem neuen Deckel', s.active && Object.keys(vo).length === 12 && s.forced === 0
diff --git a/app/test/measure.mjs b/app/test/measure.mjs
index 7952c7b..0aede1d 100644
--- a/app/test/measure.mjs
+++ b/app/test/measure.mjs
@@ -51,11 +51,15 @@ try {
check('„Messen": Modus an, Karte mit Hinweis, Auswahlkarte tritt zurück', s.active && s.text.includes('Klick auf einen Punkt, eine Kante oder eine Fläche')
&& await ev(() => document.getElementById('btn-measure').getAttribute('aria-pressed') === 'true' && getComputedStyle(document.getElementById('selcard')).display === 'none'));
- // 2) Eine Fläche: exakte Werte, Maße des Bauteils. Der erste Aufruf startet den Messdienst.
+ check('Beim Einschalten startet die Vorbereitung (Messdienst, dann Geometrie), sichtbar in der Karte', s.preparing && s.text.includes('Messdienst startet'), s.phase);
+ // Der erste Klick kommt noch während der Vorbereitung: Seine Messung wartet darauf statt ins Zeitlimit zu laufen
+
+ // 2) Eine Fläche: exakte Werte, Maße des Bauteils
const plateTop = await topFace('Platte', 5);
await clickAt(plateTop.screen);
await result(() => !!window.__t.measure().result);
s = await ms();
+ check('Nach der Vorbereitung: keine Ladezeile, kein Fehler', !s.preparing && !s.phase && !s.error, s.error);
const expArea = 40 * 30 - 2 * Math.PI * 9;
check('Klick auf die Oberseite der Platte: Fläche eben, exakter Flächeninhalt, Normale +Z', s.result?.a.type === 'PLANE' && Math.abs(s.result.a.area - expArea) < 1e-6
&& s.text.includes('Fläche · eben') && s.text.includes('+Z'), s.error || `${s.result?.a.area}`);