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

soma: Analyse, Kollisionsprüfung und Normteile allgemein verbessert (E64)

Kai-Jungsthoefel1608918fa521
diff --git a/app/test/animation.mjs b/app/test/animation.mjs
index 323b481..0e6a621 100644
--- a/app/test/animation.mjs
+++ b/app/test/animation.mjs
@@ -114,9 +114,10 @@ try {
fs.writeFileSync(path.join(dir, 'animations', 'falsch.py'), FALSCH);
await waitFor('zweite Animation', () => window.soma.anim.list().then((x) => x.animations.length === 2 && !x.building), 90000);
r = soma(['anim', 'check', 'Deckel falsch', '--step', '0.25']);
- check('soma anim check meldet die Kollision Lid / Body mit Zeit und Volumen (Exit 1)', r.status === 1 && /Lid \/ Body: Kollision, Ueberschneidung bis \d/.test(r.stdout), r.stdout + r.stderr);
+ check('soma anim check meldet die Kollision Lid / Body mit Zeit und Tiefe (Exit 1)', r.status === 1 && /Lid \/ Body: Kollision, bis \d+\.\d\d mm tief/.test(r.stdout), r.stdout + r.stderr);
r = soma(['anim', 'check', 'Deckel öffnen', '--step', '0.5']);
- check('Richtige Drehachse: keine Kollision (Exit 0), Berührung in der Lage im Modell nur mit Abstand als Hinweis', r.status === 0 && !r.stdout.includes('Kollision,'), r.stdout);
+ check('Richtige Drehachse: keine Kollision (Exit 0), der aufliegende Deckel gilt als gewollte Berührung', r.status === 0 && !r.stdout.includes('Kollision,')
+ && /Beruehren sich schon im Modell[^\n]*Lid \/ Body/.test(r.stdout), r.stdout);
r = soma(['anim', 'info', 'Deckel falsch']);
check('Ergebnis der Prüfung steht danach in soma anim info', r.stdout.includes('Lid / Body: Kollision'), r.stdout.slice(-300));
@@ -312,6 +313,53 @@ add_part("Drawer", drawer)
check('Beispiel aus dem Skill „Animation und Video“ baut ohne Fehler, Ablauf mit Titel, Gelenk und Schublade', !l.errors.length
&& r.status === 0 && r.stdout.includes('Lid: 0 -> -110 Grad') && r.stdout.includes('Drawer: 0 -> 60 mm') && r.stdout.includes('Titel: Storage box'),
JSON.stringify(l.errors) + r.stdout.slice(0, 200) + r.stderr);
+
+ // 13) Ohne App, eigener Ordner (E64): Grenzwert mit Netzgenauigkeit, Teil vor Gruppe, Problemstellen, bessere Druckrichtung,
+ // Schleife kurzer Schritte im Ablauf, Modell läuft für eine Animation nur einmal
+ const plain = fs.mkdtempSync(path.join(os.tmpdir(), 'soma-anim-plain-'));
+ fs.writeFileSync(path.join(plain, 'model.py'), `import cadquery as cq
+from soma import add_part
+from soma.fasteners import Screw
+
+with open("laeufe.txt", "a") as f:
+ f.write("x")
+PILZ_X = 60.0
+# Teil und Gruppe heissen gleich, die Fase unten hat genau 45 Grad
+box = cq.Workplane("XY").box(20, 20, 20, centered=(True, True, False)).edges("<Z and <X").chamfer(5)
+add_part("Gehäuse", box, group="Gehäuse")
+add_part("Schraube", Screw("ISO 4762", "M3x10", at=(30, 0, 5), direction="-X"), group="Gehäuse/Normteile")
+# Pilz: Der Hut steht nach +Z ueber, kopfueber gedruckt gar nicht
+pilz = cq.Workplane("XY").box(8, 8, 15, centered=(True, True, False)).union(
+ cq.Workplane("XY").box(24, 24, 4, centered=(True, True, False)).translate((0, 0, 15))).translate((PILZ_X, 0, 0))
+add_part("Pilz", pilz)
+`);
+ fs.mkdirSync(path.join(plain, 'animations'));
+ fs.writeFileSync(path.join(plain, 'animations', 'schleife.py'), `from soma.anim import Animation
+from model import PILZ_X
+
+a = Animation("Schleife")
+pilz = a.slider("Pilz", (0, 0, 1))
+for i in range(12):
+ a.play(pilz.to(i + 1), run_time=0.1, ease="linear")
+a.wait(0.5)
+`);
+ const plainSoma = (args) => soma(args, { cwd: plain });
+ r = plainSoma(['analyze', 'overhang']);
+ check('Fase mit genau 45°: nicht kritisch, als „genau am Grenzwert“ genannt', r.status === 0 && /Gehäuse: [^\n]*nichts über 45\.0°, 1\.41 cm² genau am Grenzwert/.test(r.stdout), r.stdout + r.stderr);
+ check('Pilz: Problemstelle mit Fläche und Größe, Hinweis auf --up -z', /Pilz: [^\n]*5\.12 cm² über 45\.0°, mit --up -z nur 0\.00 cm²/.test(r.stdout)
+ && /\n {4}512\.0 mm² in 24\.0 x 24\.0 mm, bis 90\.0° bei/.test(r.stdout), r.stdout);
+ r = plainSoma(['analyze', 'overhang', '--parts', 'Gehäuse', '--name', 'teil']);
+ const r2 = plainSoma(['analyze', 'overhang', '--parts', 'Gehäuse/', '--name', 'gruppe']);
+ check('--parts: Bauteil vor gleichnamiger Gruppe mit Hinweis, „Gehäuse/“ meint die Gruppe', r.status === 0 && !r.stdout.includes('Schraube:')
+ && r.stdout.includes("Hinweis: 'Gehäuse' ist Bauteil und Gruppe") && r2.status === 0 && r2.stdout.includes('Schraube:') && !r2.stdout.includes('Hinweis'), r.stdout + r2.stdout);
+ r = plainSoma(['anim', 'build']);
+ check('Animation importiert aus model.py, das Modell läuft trotzdem nur einmal', r.status === 0 && fs.readFileSync(path.join(plain, 'laeufe.txt'), 'utf8') === 'xxxx',
+ fs.readFileSync(path.join(plain, 'laeufe.txt'), 'utf8') + r.stderr);
+ r = plainSoma(['anim', 'info', 'Schleife']);
+ check('soma anim info: zwölf kurze Schritte als eine Zeile', r.status === 0 && r.stdout.includes('Pilz: 0 -> 12 mm (12 Schritte)') && !r.stdout.includes('Pilz: 1 -> 2'), r.stdout);
+ r = plainSoma(['anim', 'check', 'Schleife']);
+ check('soma anim check: frei, Exit 0', r.status === 0 && r.stdout.includes('Zeitpunkte') && r.stdout.includes('keine'), r.stdout + r.stderr);
+ cleanup(plain);
} catch (e) {
t.fail();
console.log('ABBRUCH:', e);
diff --git a/app/test/fasteners.mjs b/app/test/fasteners.mjs
index 1ef6947..d6a0297 100644
--- a/app/test/fasteners.mjs
+++ b/app/test/fasteners.mjs
@@ -35,6 +35,13 @@ def near(a, b, tol=0.01):
def overlap(a, b):
return a.intersect(b).Volume()
+def raises(fn):
+ try:
+ fn()
+ except ValueError:
+ return True
+ return False
+
# 1) Jede Norm baut einen gueltigen Koerper mit den Massen der Tabelle
rows = []
ok = True
@@ -160,6 +167,20 @@ out("add_part: Normteile ohne Angabe role \"hardware\" mit eigener Farbe, role=
and near(r["Einsatz"]["color"][:3], (0.80, 0.63, 0.32)) and isinstance(r["Schraube"]["shape"], cq.Shape),
{k: v["role"] for k, v in r.items()})
registry.REGISTRY.clear()
+
+# 10) Bewegen wie eine CadQuery-Form: Kopie mit neuer Lage, Bohrung wandert mit, das Original bleibt
+s0 = Screw("ISO 4762", "M3x16", at=(10, 0, 20))
+sr = s0.rotate((0, 0, 0), (0, 1, 0), 90)
+sref = Screw("ISO 4762", "M3x16", at=(20, 0, -10), direction="-X")
+h1, h2 = sr.clearance_hole(), sref.clearance_hole()
+out("rotate(): Auflage, Richtung und Durchgangsloch wie neu angelegt, Original unverändert",
+ near(sr.seat, (20, 0, -10)) and near(sr.direction, (-1, 0, 0)) and h1.cut(h2).Volume() + h2.cut(h1).Volume() < 1e-6
+ and near(s0.seat, (10, 0, 20)) and sr.designation == "ISO 4762 M3x16", (sr.seat, sr.direction))
+n0 = Nut("ISO 4032", "M3", at=(0, 0, 0))
+n30 = Nut("ISO 4032", "M3", at=(0, 0, 0), angle=30)
+nr = n0.rotate((0, 0, 0), (0, 0, 1), 30).translate((0, 0, 5))
+out("rotate() dreht den Sechskant mit, translate() verschiebt, moved() verlangt eine Location",
+ nr.shape.translate((0, 0, -5)).cut(n30.shape).Volume() < 1e-6 and near(nr.seat, (0, 0, 5)) and raises(lambda: n0.moved((1, 2, 3))), nr.seat)
`;
const MODEL = `import cadquery as cq
@@ -200,7 +221,7 @@ try {
const lib = py(['-c', LIB_CHECKS]);
const lines = lib.stdout.split(/\r?\n/).filter((l) => l.startsWith('['));
for (const l of lines) { const [label, ok, detail] = JSON.parse(l); check(label, ok, ok ? '' : detail); }
- check('Python-Prüfungen liefen durch', lib.status === 0 && lines.length >= 26, lib.status !== 0 ? lib.stderr.slice(-300) : String(lines.length));
+ check('Python-Prüfungen liefen durch', lib.status === 0 && lines.length >= 28, lib.status !== 0 ? lib.stderr.slice(-300) : String(lines.length));
// Der Skill „Normteile“ erklärt dem Agenten die Bibliothek: sein Codeblock und die genannten Aufrufe müssen laufen
const skill = fs.readFileSync(path.join(APP, 'resources', 'skills', 'normteile.md'), 'utf8');
diff --git a/python/soma/analysis.py b/python/soma/analysis.py
index 6f09018..54b883e 100644
--- a/python/soma/analysis.py
+++ b/python/soma/analysis.py
@@ -35,30 +35,29 @@ class AnalysisError(Exception):
# ---- Netz -------------------------------------------------------------------------------------------------------
def _subdivide(pos, nrm, idx, h, max_tris):
- """Dreiecke halbieren, bis keine Kante laenger als h ist (oder die Hoechstzahl erreicht ist). Neue Punkte liegen auf den
- alten Kanten, die Form aendert sich nicht. Nur so bekommt eine grosse ebene Flaeche mehr als vier Messstellen."""
- for _ in range(10):
+ """Dreiecke an ihrer laengsten Kante halbieren, bis keine Kante laenger als h ist (oder die Hoechstzahl erreicht ist).
+ Neue Punkte liegen auf den alten Kanten, die Form aendert sich nicht. Nur so bekommt eine grosse ebene Flaeche mehr als
+ vier Messstellen. Nur die laengste Kante: Ein langes, schmales Dreieck (Mantel eines Zylinders) wird so zu einer Reihe.
+ Beim Vierteln an allen drei Kanten wurden es Tausende, die Ergebnisse wuchsen auf 70 MB."""
+ for _ in range(64):
p = pos[idx]
- l = np.max(np.stack([np.linalg.norm(p[:, 0] - p[:, 1], axis=1), np.linalg.norm(p[:, 1] - p[:, 2], axis=1),
- np.linalg.norm(p[:, 2] - p[:, 0], axis=1)]), axis=0)
- mask = l > h
- if not mask.any() or len(idx) + 3 * int(mask.sum()) > max_tris:
+ e = np.stack([np.linalg.norm(p[:, 1] - p[:, 0], axis=1), np.linalg.norm(p[:, 2] - p[:, 1], axis=1),
+ np.linalg.norm(p[:, 0] - p[:, 2], axis=1)], axis=1)
+ mask = e.max(axis=1) > h
+ if not mask.any() or len(idx) + int(mask.sum()) > max_tris:
break
- sel = idx[mask]
- edges = np.concatenate([sel[:, [0, 1]], sel[:, [1, 2]], sel[:, [2, 0]]])
- uniq, inv = np.unique(np.sort(edges, axis=1), axis=0, return_inverse=True)
- inv = inv.reshape(-1)
+ sel, k = idx[mask], e[mask].argmax(axis=1)
+ r = np.arange(len(sel))
+ # Ecken reihum drehen, bis die laengste Kante a-b ist (Kante 0 = Ecke 0-1, 1 = 1-2, 2 = 2-0), die Umlaufrichtung bleibt
+ a, b, c = sel[r, k], sel[r, (k + 1) % 3], sel[r, (k + 2) % 3]
+ uniq, inv = np.unique(np.sort(np.stack([a, b], axis=1), axis=1), axis=0, return_inverse=True)
mid_p = (pos[uniq[:, 0]] + pos[uniq[:, 1]]) / 2
mid_n = nrm[uniq[:, 0]] + nrm[uniq[:, 1]]
ln = np.linalg.norm(mid_n, axis=1, keepdims=True)
mid_n = np.where(ln > 1e-12, mid_n / np.maximum(ln, 1e-12), nrm[uniq[:, 0]])
- base = len(pos)
+ m = len(pos) + inv.reshape(-1)
pos, nrm = np.concatenate([pos, mid_p]), np.concatenate([nrm, mid_n])
- n = len(sel)
- ab, bc, ca = base + inv[:n], base + inv[n:2 * n], base + inv[2 * n:]
- a, b, c = sel[:, 0], sel[:, 1], sel[:, 2]
- new = np.concatenate([np.stack([a, ab, ca], 1), np.stack([ab, b, bc], 1), np.stack([ca, bc, c], 1), np.stack([ab, bc, ca], 1)])
- idx = np.concatenate([idx[~mask], new])
+ idx = np.concatenate([idx[~mask], np.stack([a, m, c], axis=1), np.stack([m, b, c], axis=1)])
return pos, nrm, idx
@@ -92,7 +91,7 @@ def _overhang(tri, normals, up):
return angle
-def _thickness(tri, normals, own_pd, diag):
+def _thickness(tri, normals, own_pd, diag, progress=None):
from vtkmodules.vtkCommonCore import vtkIdList, vtkPoints
from vtkmodules.vtkFiltersGeneral import vtkOBBTree
tree = vtkOBBTree()
@@ -103,24 +102,40 @@ def _thickness(tri, normals, own_pd, diag):
cen = tri.mean(axis=1)
pts, ids = vtkPoints(), vtkIdList()
out = np.full(len(cen), np.nan)
- for i in range(len(cen)):
- p0 = cen[i] - normals[i] * eps
- p1 = cen[i] - normals[i] * length
+
+ def shoot(p0, d):
pts.Reset()
- if tree.IntersectWithLine(p0, p1, pts, ids) == 0 or pts.GetNumberOfPoints() == 0:
- continue
+ if tree.IntersectWithLine(p0, p0 + d * length, pts, ids) == 0:
+ return math.inf
best = math.inf
for k in range(pts.GetNumberOfPoints()):
- q = pts.GetPoint(k)
- d = math.dist(q, p0)
- if d > eps * 0.5 and d < best:
- best = d
+ dist = math.dist(pts.GetPoint(k), p0)
+ if eps * 0.5 < dist < best:
+ best = dist
+ return best
+
+ for i in range(len(cen)):
+ if progress and i % 2000 == 0:
+ progress.step(min(2000, len(cen) - i))
+ p0 = cen[i] - normals[i] * eps
+ best = shoot(p0, -normals[i])
+ if best == math.inf and np.linalg.norm(normals[i]) > 0.5: # entartete Dreiecke haben keine Normale
+ # Trifft der Strahl genau eine Ecke oder Kante des Netzes (Spitze einer Kugel, Achse eines Kegels), rutscht er
+ # mitunter durch. Zwei um knapp 2 Grad gekippte Strahlen, erst wenn alle ins Leere gehen, fehlt die Gegenseite.
+ t1 = np.cross(normals[i], (1.0, 0.0, 0.0) if abs(normals[i][0]) < 0.9 else (0.0, 1.0, 0.0))
+ t1 /= np.linalg.norm(t1)
+ t2 = np.cross(normals[i], t1)
+ for t in (t1, t2):
+ d = -normals[i] + 0.03 * t
+ best = shoot(p0, d / np.linalg.norm(d))
+ if best < math.inf:
+ break
if best < math.inf:
out[i] = best + eps
return out
-def _clearance(tri, normals, others_pd, limit, contact):
+def _clearance(tri, normals, others_pd, limit, contact, progress=None):
"""Spalt vor jeder Stelle: Strahl entlang der Flaechennormalen nach aussen bis zum naechsten anderen Bauteil. So zaehlt
der Spalt zwischen Stift und Bohrung, nicht aber eine Wand, die nur neben einer Auflageflaeche endet. Liegt die
Stelle in einem anderen Bauteil, ist der Wert negativ (Eindringtiefe), auf einer Auflageflaeche 0."""
@@ -137,6 +152,8 @@ def _clearance(tri, normals, others_pd, limit, contact):
pts, ids = vtkPoints(), vtkIdList()
out = np.full(len(cen), float(limit))
for i in range(len(cen)):
+ if progress and i % 2000 == 0:
+ progress.step(min(2000, len(cen) - i))
sd = f.EvaluateFunction(cen[i])
if sd < -contact:
out[i] = max(sd, -limit)
@@ -155,17 +172,30 @@ def _clearance(tri, normals, others_pd, limit, contact):
# ---- Ablauf -----------------------------------------------------------------------------------------------------
+def _group_path(p):
+ return "/".join(p.get("group", ()))
+
+
def _pick(parts, spec, default_roles):
+ """Auswahl wie in soma.anim: ein Bauteilname gilt vor einer gleichnamigen Gruppe, "Gruppe/" (mit Schraegstrich) meint
+ immer die Gruppe. Liefert (Bauteile, Hinweise)."""
if not spec:
- return [p for p in parts if p["role"] in default_roles]
- out = []
+ return [p for p in parts if p["role"] in default_roles], []
+ out, notes = [], []
for s in [x.strip() for x in spec.split(",") if x.strip()]:
- hit = [p for p in parts if p["name"] == s or "/".join(p.get("group", ())) == s or "/".join(p.get("group", ())).startswith(s + "/")]
+ path = s.strip("/")
+ group = [p for p in parts if _group_path(p) == path or _group_path(p).startswith(path + "/")]
+ part = [p for p in parts if p["name"] == s]
+ if part and group:
+ notes.append(f"{s!r} ist Bauteil und Gruppe: ausgewertet ist das Bauteil, die Gruppe mit --parts \"{path}/\"")
+ hit = part or group
if not hit:
names = ", ".join(repr(p["name"]) for p in parts[:30])
- raise AnalysisError(f"Bauteil oder Gruppe {s!r} gibt es nicht. Bauteile: {names}")
+ groups = sorted({_group_path(p) for p in parts if p.get("group")})
+ raise AnalysisError(f"Bauteil oder Gruppe {s!r} gibt es nicht. Bauteile: {names}"
+ + (f". Gruppen: {', '.join(repr(g) for g in groups)}" if groups else ""))
out += [p for p in hit if p not in out]
- return out
+ return out, notes
def _fmt(v, unit):
@@ -173,24 +203,86 @@ def _fmt(v, unit):
return f"{v:.1f}{unit}" if unit == "°" else f"{v:.2f} {unit}"
+AXES = {"x": (1, 0, 0), "y": (0, 1, 0), "z": (0, 0, 1), "-x": (-1, 0, 0), "-y": (0, -1, 0), "-z": (0, 0, -1)}
+MAX_REGIONS = 200 # so viele groesste Stellen je Teil werden vermessen, der Rest nur gezaehlt
+
+
+def _extent(pts):
+ """Ausdehnung einer Stelle (mm), groessere zuerst: das kleinere Rechteck aus Hauptrichtungen und Achsen. Die
+ Hauptrichtungen fassen einen schraegen Streifen eng, bei einem quadratischen Ring sind sie aber beliebig (Diagonale)."""
+ c = pts - pts.mean(axis=0)
+ _u, _s, vt = np.linalg.svd(c, full_matrices=False)
+ e1 = sorted(np.ptp(c @ vt.T, axis=0).tolist(), reverse=True)[:2]
+ e2 = sorted(np.ptp(pts, axis=0).tolist(), reverse=True)[:2]
+ e = e1 if e1[0] * e1[1] < e2[0] * e2[1] - 1e-9 else e2
+ return [round(e[0], 2), round(e[1], 2)]
+
+
+def _regions(tri, area, vals, crit, high, weld):
+ """Zusammenhaengende kritische Stellen: Dreiecke mit gemeinsamer Ecke gehoeren zusammen. Liefert (Stellen, Anzahl
+ aller Stellen, Flaeche aller Stellen). Je Stelle Flaeche (mm2), Ausdehnung, schlechtester Wert und seine Lage."""
+ from scipy.sparse import coo_matrix
+ from scipy.sparse.csgraph import connected_components
+ ids = np.nonzero(crit)[0]
+ if not len(ids):
+ return [], 0, 0.0
+ # Die Flaechen eines Teils sind einzeln vernetzt: gleiche Ecken an den Kanten erst zusammenfuehren
+ _, vid = np.unique(np.round(tri[ids].reshape(-1, 3) / weld).astype(np.int64), axis=0, return_inverse=True)
+ vid = vid.reshape(-1)
+ n, nv = len(ids), int(vid.max()) + 1
+ graph = coo_matrix((np.ones(3 * n), (np.repeat(np.arange(n), 3), n + vid)), shape=(n + nv, n + nv))
+ _k, lab = connected_components(graph, directed=False)
+ lab = lab[:n]
+ order = np.argsort(lab, kind="stable")
+ starts = np.r_[0, np.nonzero(np.diff(lab[order]))[0] + 1]
+ ends = np.r_[starts[1:], n]
+ comp_area = np.add.reduceat(area[ids][order], starts)
+ out = []
+ for k in np.argsort(-comp_area)[:MAX_REGIONS]:
+ sel = ids[order[starts[k]:ends[k]]]
+ v = vals[sel]
+ w = sel[int(np.argmax(v) if high else np.argmin(v))]
+ out.append(dict(area=round(float(comp_area[k]), 2), size=_extent(tri[sel].reshape(-1, 3)),
+ worst=round(float(vals[w]), 4), at=[round(float(x), 2) for x in tri[w].mean(axis=0)]))
+ return out, len(starts), float(comp_area.sum())
+
+
+def _similar(regions, val_tol):
+ """Gleichartige Stellen (Zahnspitzen, gleiche Bohrungen) zu Gruppen: Flaeche und Ausdehnung auf 15 % gleich, Wert auf
+ val_tol. Groesste Gesamtflaeche zuerst."""
+ groups = []
+ for r in regions:
+ for g in groups:
+ f = g[0]
+ if (abs(r["area"] - f["area"]) <= 0.15 * f["area"] + 0.01 and abs(r["worst"] - f["worst"]) <= val_tol
+ and all(abs(a - b) <= 0.15 * b + 0.05 for a, b in zip(r["size"], f["size"]))):
+ g.append(r)
+ break
+ else:
+ groups.append([r])
+ groups.sort(key=lambda g: -sum(r["area"] for r in g))
+ return [dict(g[0], count=len(g), total=round(sum(r["area"] for r in g), 2)) for g in groups]
+
+
def run(root, kind, parts_spec=None, threshold=None, up="z", name=None):
"""Fuehrt eine Auswertung aus, schreibt .soma/results/<name>.glb und gibt die Metadaten zurueck."""
+ from .progress import Progress
if kind not in KINDS:
raise AnalysisError(f"Unbekannte Auswertung {kind!r}. Moeglich: {', '.join(KINDS)}")
spec = KINDS[kind]
+ high = spec["bad"] == "high"
thr = spec["threshold"] if threshold is None else float(threshold)
root = Path(root).resolve()
try:
parts = build.run_model(root)
except build.BuildError as e:
raise AnalysisError(f"Das Modell laesst sich nicht bauen: {e.message}" + (f" ({e.file}:{e.line})" if e.file and e.line else "")) from None
- chosen = _pick(parts, parts_spec, ("part",))
+ chosen, notes = _pick(parts, parts_spec, ("part",))
if not chosen:
raise AnalysisError("Keine Bauteile zum Auswerten (ohne --parts zaehlen nur eigene Teile, keine Referenzen und Zukaufteile).")
- axis = {"x": (1, 0, 0), "y": (0, 1, 0), "z": (0, 0, 1), "-x": (-1, 0, 0), "-y": (0, -1, 0), "-z": (0, 0, -1)}
- if up not in axis:
- raise AnalysisError(f"--up {up!r} gibt es nicht. Moeglich: {', '.join(axis)}")
- upv = np.asarray(axis[up], dtype=float)
+ if up not in AXES:
+ raise AnalysisError(f"--up {up!r} gibt es nicht. Moeglich: {', '.join(AXES)}")
+ upv = np.asarray(AXES[up], dtype=float)
tol = build.auto_tolerance([p["shape"] for p in parts])
meshes = {p["name"]: mesher.mesh_shape(p["shape"], tol, 0.3) for p in parts}
lo = np.min([m["positions"].min(axis=0) for m in meshes.values() if len(m["positions"])], axis=0)
@@ -199,6 +291,9 @@ def run(root, kind, parts_spec=None, threshold=None, up="z", name=None):
h = max(diag_all / 100, 0.2)
# Beruehrung: innerhalb der Netztoleranz gilt ein Abstand als 0 (gekruemmte Flaechen weichen um die Toleranz ab)
contact = round(max(0.01, 2 * tol), 4)
+ # Werte so nah am Grenzwert, wie das Netz genau ist, zaehlen als genau auf dem Grenzwert, also nicht kritisch: Ein Dach
+ # mit genau 45 Grad oder genau 0,2 mm Spiel lag durch Rundung sonst knapp darueber.
+ band = 0.5 if kind == "overhang" else round(max(0.005, tol), 4)
if kind == "clearance" and len(parts) < 2:
raise AnalysisError("Der Abstand braucht mindestens zwei Bauteile.")
g = gltf.Glb()
@@ -206,23 +301,25 @@ def run(root, kind, parts_spec=None, threshold=None, up="z", name=None):
face_mat = g.material(name="result", doubleSided=True, pbrMetallicRoughness=dict(baseColorFactor=[1, 1, 1, 1], metallicFactor=0, roughnessFactor=0.7))
children, stats = [], []
t_start = time.perf_counter()
+ work = []
for i, p in enumerate(parts):
- if p not in chosen:
- continue
m = meshes[p["name"]]
- if not m["indices"].size:
+ if p not in chosen or not m["indices"].size:
continue
pos, nrm, idx = m["positions"].astype(float), m["normals"].astype(float), m["indices"].astype(np.int64)
- pos2, nrm2, idx2 = _subdivide(pos, nrm, idx, h, 150000)
+ work.append((i, p, m, pos, idx, _subdivide(pos, nrm, idx, h, 150000)))
+ progress = Progress(f"soma analyze {kind}", sum(len(w[5][2]) for w in work), "Messstellen")
+ for i, p, m, pos, idx, (pos2, nrm2, idx2) in work:
tri = pos2[idx2]
fn = np.cross(tri[:, 1] - tri[:, 0], tri[:, 2] - tri[:, 0])
area = np.linalg.norm(fn, axis=1) / 2
fn = fn / np.maximum(np.linalg.norm(fn, axis=1, keepdims=True), 1e-12)
if kind == "overhang":
vals = _overhang(tri, fn, upv)
+ progress.step(len(tri))
elif kind == "thickness":
diag = float(np.linalg.norm(pos.max(axis=0) - pos.min(axis=0)))
- vals = _thickness(tri, fn, _polydata(pos, idx), diag)
+ vals = _thickness(tri, fn, _polydata(pos, idx), diag, progress)
else:
from vtkmodules.vtkFiltersCore import vtkAppendPolyData
app = vtkAppendPolyData()
@@ -231,26 +328,41 @@ def run(root, kind, parts_spec=None, threshold=None, up="z", name=None):
app.AddInputData(_polydata(meshes[q["name"]]["positions"].astype(float), meshes[q["name"]]["indices"].astype(np.int64)))
app.Update()
others = app.GetOutput()
- vals = _clearance(tri, fn, others, max(10 * thr, 5.0), contact)
+ vals = _clearance(tri, fn, others, max(10 * thr, 5.0), contact, progress)
valid = ~np.isnan(vals)
- if kind == "thickness":
- vals = np.where(valid, vals, np.nan)
- crit = (vals > thr) if spec["bad"] == "high" else (vals < thr)
+ vals = np.where(valid & (np.abs(vals - thr) <= band), thr, vals)
+ crit = (vals > thr) if high else (vals < thr)
crit &= valid
if kind == "clearance": # Beruehrung (aufliegender Deckel, Stift in Bohrung) ist gewollt, nicht kritisch
crit &= np.abs(vals) > contact
- st = dict(name=p["name"], group="/".join(p.get("group", ())) or None, area=round(float(area.sum()), 3),
+ st = dict(name=p["name"], group=_group_path(p) or None, area=round(float(area.sum()), 3),
critical=round(float(area[crit].sum()), 3), triangles=int(len(idx2)))
+ limit = float(area[valid & (vals == thr)].sum())
+ if limit >= 0.5:
+ st["limit"] = round(limit, 3)
if valid.any():
vv = vals[valid]
st["min"], st["max"] = round(float(vv.min()), 4), round(float(vv.max()), 4)
- w = int(np.nanargmax(vals) if spec["bad"] == "high" else np.nanargmin(vals))
+ w = int(np.nanargmax(vals) if high else np.nanargmin(vals))
st["worst"] = dict(value=round(float(vals[w]), 4), at=[round(float(x), 3) for x in tri[w].mean(axis=0)])
+ if crit.any():
+ regs, count, total = _regions(tri, area, vals, crit, high, max(1e-4, diag_all * 1e-7))
+ groups = _similar(regs, max(band, 0.1 * abs(thr)))
+ st["regions"] = groups[:3]
+ shown = sum(gr["count"] for gr in st["regions"])
+ if count > shown:
+ st["regionsMore"] = dict(count=count - shown, area=round(total - sum(gr["total"] for gr in st["regions"]), 2))
+ if kind == "overhang" and st["critical"] > 0:
+ # Eine andere Druckrichtung, die deutlich weniger Ueberhang hat? Kostet nichts, es haengt nur an den Normalen.
+ best = min(((ax, float(area[_overhang(tri, fn, np.asarray(v, dtype=float)) > thr + band].sum())) for ax, v in AXES.items()),
+ key=lambda x: x[1])
+ if best[0] != up and best[1] < 0.5 * st["critical"] and st["critical"] - best[1] >= 10.0:
+ st["betterUp"] = dict(up=best[0], critical=round(best[1], 3))
if kind == "clearance":
st["overlap"] = round(float(area[valid & (vals < -contact)].sum()), 3)
st["contact"] = round(float(area[valid & (np.abs(vals) <= contact)].sum()), 3)
- if kind == "thickness":
- st["open"] = int((~valid).sum())
+ if kind == "thickness": # ohne entartete Dreiecke (Flaeche 0, keine Richtung fuer den Strahl)
+ st["open"] = int((~valid & (area > 1e-9)).sum())
stats.append(st)
# Je Dreieck drei eigene Ecken: der Wert gilt fuer das ganze Dreieck
flat_pos = tri.reshape(-1, 3)
@@ -264,6 +376,7 @@ def run(root, kind, parts_spec=None, threshold=None, up="z", name=None):
mesh = g.mesh(p["step_name"], prims)
children.append(g.node(name=f"{i}:{p['step_name']}", mesh=mesh, extras=dict(soma=dict(
partId=f"{i}:{p['step_name']}", name=p["name"], role=p["role"], group=st["group"], result=True))))
+ progress.finish()
seconds = time.perf_counter() - t_start
unit = spec["unit"]
if kind == "overhang":
@@ -274,8 +387,8 @@ def run(root, kind, parts_spec=None, threshold=None, up="z", name=None):
rng = [round(-thr, 3), round(max(4 * thr, 2.0), 3)]
rid = name or kind
meta = dict(version=1, id=rid, kind=kind, title=spec["title"], quantity=spec["quantity"], unit=unit, bad=spec["bad"],
- threshold=thr, range=rng, up=up if kind == "overhang" else None, parts=stats, created=time.time(),
- neutral=[-contact, contact] if kind == "clearance" else None,
+ threshold=thr, tolerance=band, range=rng, up=up if kind == "overhang" else None, parts=stats, notes=notes,
+ created=time.time(), neutral=[-contact, contact] if kind == "clearance" else None,
seconds=round(seconds, 2), command=["analyze", kind] + ([f"--parts={parts_spec}"] if parts_spec else [])
+ [f"--threshold={thr:g}"] + ([f"--up={up}"] if kind == "overhang" and up != "z" else []) + ([f"--name={name}"] if name else []))
meta["summary"] = summary_text(meta)
@@ -289,10 +402,28 @@ def run(root, kind, parts_spec=None, threshold=None, up="z", name=None):
return meta
+def _where(at):
+ return "({:.1f}, {:.1f}, {:.1f})".format(*at)
+
+
+def _mm2(a):
+ return f"{a:.1f} mm²" if a >= 1 else f"{a:.2f} mm²"
+
+
+def _region_line(r, unit):
+ size = f"{r['size'][0]:.1f} x {r['size'][1]:.1f} mm"
+ if r.get("count", 1) > 1:
+ return f"{r['count']} gleichartige Stellen je {_mm2(r['area'])} in {size}, bis {_fmt(r['worst'], unit)}, z. B. bei {_where(r['at'])}"
+ return f"{_mm2(r['area'])} in {size}, bis {_fmt(r['worst'], unit)} bei {_where(r['at'])}"
+
+
def summary_text(meta):
unit, thr = meta["unit"], meta["threshold"]
worse = "über" if meta["bad"] == "high" else "unter"
- head = f"{meta['title']} (Grenzwert {_fmt(thr, unit)}, kritisch {worse} dem Grenzwert)"
+ head = f"{meta['title']} (Grenzwert {_fmt(thr, unit)}, kritisch {worse} dem Grenzwert"
+ if meta.get("tolerance"):
+ head += f", auf ±{meta['tolerance']:g}{'°' if unit == '°' else ' ' + unit} genau"
+ head += ")"
if meta["kind"] == "overhang":
head += f", Druckrichtung +{meta['up'].lstrip('-')}" if not (meta["up"] or "").startswith("-") else f", Druckrichtung {meta['up']}"
lines = [head + ":"]
@@ -303,16 +434,27 @@ def summary_text(meta):
rng = f"{_fmt(st['min'], unit)} bis {_fmt(st['max'], unit)}"
crit = f"{st['critical'] / 100:.2f} cm² {worse} {_fmt(thr, unit)}" if st["critical"] > 0 else f"nichts {worse} {_fmt(thr, unit)}"
w = st["worst"]
- where = " bei ({:.1f}, {:.1f}, {:.1f})".format(*w["at"])
extra = ""
+ if st.get("limit"):
+ extra += f", {st['limit'] / 100:.2f} cm² genau am Grenzwert"
if st.get("overlap"):
extra += f", davon {st['overlap'] / 100:.2f} cm² Ueberschneidung"
if st.get("contact"):
extra += f", {st['contact'] / 100:.2f} cm² Beruehrung (nicht kritisch)"
if st.get("open"):
extra += f", {st['open']} Stellen ohne Gegenseite (offene Flaeche?)"
- worst = f", {'groesster' if meta['bad'] == 'high' else 'kleinster'} Wert {_fmt(w['value'], unit)}{where}" if st["critical"] > 0 else ""
+ if st.get("betterUp"):
+ b = st["betterUp"]
+ extra += f", mit --up {b['up']} nur {b['critical'] / 100:.2f} cm²"
+ worst = f", {'groesster' if meta['bad'] == 'high' else 'kleinster'} Wert {_fmt(w['value'], unit)} bei {_where(w['at'])}" if st["critical"] > 0 else ""
lines.append(f" {st['name']}: {rng}, {crit}{extra}{worst}")
+ for r in st.get("regions", []):
+ lines.append(f" {_region_line(r, unit)}")
+ if st.get("regionsMore"):
+ mo = st["regionsMore"]
+ lines.append(f" und {mo['count']} weitere Stelle{'n' if mo['count'] > 1 else ''}, zusammen {_mm2(mo['area'])}")
+ for n in meta.get("notes") or []:
+ lines.append(f"Hinweis: {n}")
return "\n".join(lines)
diff --git a/python/soma/anim.py b/python/soma/anim.py
index 0c5fe8e..3871a2f 100644
--- a/python/soma/anim.py
+++ b/python/soma/anim.py
@@ -231,6 +231,8 @@ class _Action:
class Joint:
"""Bauteile, die sich gemeinsam bewegen. Entsteht ueber Animation.hinge(), slider() oder part()."""
+ unit = None # Einheit des Gelenkwerts (Grad, mm), None bei frei bewegten Teilen
+
def __init__(self, anim, kind, parts, parent, value):
self.anim, self.kind, self.parts, self.parent = anim, kind, parts, parent
self.value = value # Stand am Ende der bisher beschriebenen Zeitleiste
@@ -259,6 +261,8 @@ class Joint:
class _Hinge(Joint):
+ unit = "Grad"
+
def __init__(self, anim, parts, p1, axis, parent, angle):
super().__init__(anim, "hinge", parts, parent, angle)
self.p1, self.axis = p1, axis
@@ -278,6 +282,8 @@ class _Hinge(Joint):
class _Slider(Joint):
+ unit = "mm"
+
def __init__(self, anim, parts, direction, parent, position):
super().__init__(anim, "slider", parts, parent, position)
self.direction = direction
@@ -449,8 +455,10 @@ class Animation:
# -- Zeitleiste --
- def _step(self, t0, t1, text):
- self.steps.append(dict(start=round(t0, 4), end=round(t1, 4), text=text))
+ def _step(self, t0, t1, text, **move):
+ """Eintrag im Ablauf. move (bei Bewegungen): key (Gelenk oder Kamera), label, unit, v0, v1 bzw. orbit, tilt.
+ Damit fasst `soma anim info` viele kurze Schritte desselben Gelenks zu einer Zeile zusammen."""
+ self.steps.append(dict(start=round(t0, 4), end=round(t1, 4), text=text, **move))
def play(self, *actions, run_time=1.0, ease="smooth"):
"""Bewegungen gleichzeitig ablaufen lassen, dann geht die Zeit um run_time (Sekunden) weiter.
@@ -470,14 +478,18 @@ class Animation:
if isinstance(act.target, Camera):
kind, spec = act.make
act.target.ops.append(dict(t0=t0, t1=t1, kind=kind, spec=spec, ease=f))
- self._step(t0, t1, act.describe(None))
+ self._step(t0, t1, act.describe(None), key="camera",
+ **(dict(orbit=spec["orbit"], tilt=spec["tilt"]) if kind == "orbit" else {}))
continue
j = act.target
if j.anim is not self:
raise ValueError("Diese Bewegung gehoert zu einer anderen Animation")
func, end = act.make(j.value)
j.segments.append((t0, t1, func, f))
- self._step(t0, t1, act.describe(j.value))
+ move = dict(key=f"joint{self.joints.index(j)}", label=j.label)
+ if j.unit:
+ move.update(unit=j.unit, v0=round(float(j.value), 4), v1=round(float(end), 4))
+ self._step(t0, t1, act.describe(j.value), **move)
j.value = end
self.time = t1
diff --git a/python/soma/animrun.py b/python/soma/animrun.py
index dd4ece1..ccab4d8 100644
--- a/python/soma/animrun.py
+++ b/python/soma/animrun.py
@@ -10,6 +10,7 @@ import os
import runpy
import sys
import time
+import types
from pathlib import Path
import numpy as np
@@ -76,6 +77,16 @@ def _run_file(root, path):
os.chdir(root)
sys.path.insert(0, str(root))
registry.IGNORE_ADD = True
+ # Das Modell ist eben gelaufen: sein Namensraum wird das Modul `model`, `from model import ...` fuehrt es nicht noch
+ # einmal aus (das kostete bei grossen Modellen so lange wie ein ganzer Build).
+ mod_name, old_mod = None, None
+ if build.LAST_RUN and Path(build.LAST_RUN[0]).resolve().parent == Path(root).resolve() and build.LAST_RUN[0].stem.isidentifier():
+ script, ns = build.LAST_RUN
+ mod_name, old_mod = script.stem, sys.modules.get(script.stem)
+ mod = types.ModuleType(mod_name)
+ mod.__dict__.update(ns)
+ mod.__name__, mod.__file__ = mod_name, str(script)
+ sys.modules[mod_name] = mod
try:
runpy.run_path(str(path), run_name="__main__")
except SystemExit as e:
@@ -85,6 +96,11 @@ def _run_file(root, path):
raise build._error_from_exception(e, root)
finally:
registry.IGNORE_ADD = False
+ if mod_name:
+ if old_mod is None:
+ sys.modules.pop(mod_name, None)
+ else:
+ sys.modules[mod_name] = old_mod
os.chdir(old_cwd)
if sys.path and sys.path[0] == str(root):
sys.path.pop(0)
@@ -432,13 +448,71 @@ def _t(x):
return f"{x:.2f}"
+SHORT_STEP = 0.5 # s: kuerzere Bewegungen desselben Gelenks ohne Luecke fasst der Ablauf zusammen
+
+
+def _g(v):
+ return f"{round(v, 2):g}"
+
+
+def _merge(run):
+ """Eine Folge kurzer Schritte eines Gelenks (oder der Kamera) als ein Eintrag."""
+ first, n = run[0], len(run)
+ s = dict(start=first["start"], end=run[-1]["end"])
+ if first.get("unit"):
+ vals = [x["v0"] for x in run] + [x["v1"] for x in run]
+ v0, v1, lo, hi = first["v0"], run[-1]["v1"], min(vals), max(vals)
+ text = f"{first['label']}: {_g(v0)} -> {_g(v1)} {first['unit']}"
+ if lo < min(v0, v1) - 1e-6 or hi > max(v0, v1) + 1e-6:
+ text += f", dazwischen {_g(lo)} bis {_g(hi)} {first['unit']}"
+ elif first["key"] == "camera" and all("orbit" in x for x in run):
+ orbit, tilt = sum(x["orbit"] for x in run), sum(x["tilt"] for x in run)
+ text = f"Kamera: Umlauf {_g(orbit)} Grad" + (f", Neigung {_g(tilt)} Grad" if abs(tilt) > 1e-9 else "")
+ else:
+ text = first["text"].split(":")[0] + ": Bewegung"
+ s["text"] = f"{text} ({n} Schritte)"
+ return s
+
+
+def _compact_steps(steps):
+ """Viele kurze, lueckenlose Schritte desselben Gelenks (Schleife mit play(), etwa fuer eine gekoppelte Bewegung) als eine
+ Zeile. Andere Eintraege (Untertitel, Pausen, lange Bewegungen) unterbrechen eine Folge, damit der Ablauf lesbar bleibt."""
+ out, runs = [], {}
+
+ def flush(key):
+ run = runs.pop(key)
+ if len(run) >= 3:
+ out.append(_merge(run))
+ else:
+ out.extend(run)
+
+ for s in steps:
+ key = s.get("key")
+ if key is None or s["end"] - s["start"] > SHORT_STEP:
+ for k in list(runs):
+ flush(k)
+ out.append(s)
+ continue
+ run = runs.get(key)
+ if run and abs(run[-1]["end"] - s["start"]) > 1e-6:
+ flush(key)
+ run = None
+ if run is None:
+ runs[key] = [s]
+ else:
+ run.append(s)
+ for k in list(runs):
+ flush(k)
+ return sorted(out, key=lambda s: s["start"])
+
+
def info_text(root, entry):
m = read_meta(root, entry)
lines = [f"Animation \"{m['name']}\" ({m['file']} Zeile {m['line']}), Dauer {_t(m['duration'])} s",
f"Bewegte Bauteile: {', '.join(m['parts']) or 'keine'}",
"Kamera: " + ("keine eigene (Standardansicht iso, alles im Bild)" if m["cameraAuto"] else "eigene Einstellungen und Fahrten"),
"", "Ablauf:"]
- for s in m["steps"]:
+ for s in _compact_steps(m["steps"]):
span = f"{_t(s['start'])}-{_t(s['end'])} s" if s["end"] > s["start"] else f"{_t(s['start'])} s"
lines.append(f" {span:<16} {s['text']}")
if m["captions"]:
@@ -465,71 +539,204 @@ def _location(m):
return cq.Location(t)
+def _signed(f, pts):
+ """Vorzeichenbehafteter Abstand der Punkte zur Oberflaeche (negativ: innen), in einem Aufruf ueber VTK."""
+ from vtkmodules.util.numpy_support import numpy_to_vtk, vtk_to_numpy
+ from vtkmodules.vtkCommonCore import vtkDoubleArray
+ if not len(pts):
+ return np.empty(0)
+ out = vtkDoubleArray()
+ f.FunctionValue(numpy_to_vtk(np.ascontiguousarray(pts, dtype=np.float64), deep=True), out)
+ return vtk_to_numpy(out).copy()
+
+
+VOL_MIN = 1e-3 # mm3: kleinere Schnittmengen der B-Rep-Koerper sind Rechenrauschen an Beruehrflaechen
+
+
def check(root, name, step=0.1, gap=0.0):
"""Prueft die Bewegung: Ueberschneiden sich Bauteile (oder kommen sich naeher als gap mm)? Bewegte Bauteile gegen alle
- anderen, zu jeder Abtastzeit im Abstand step und an den Grenzen jedes Schritts. Schreibt .soma/anim/<id>.check.json."""
- from OCP.BRepExtrema import BRepExtrema_DistShapeShape
+ anderen, zu jedem Zeitpunkt im Abstand step und am Ende jeder laengeren Bewegung. Schreibt .soma/anim/<id>.check.json.
+
+ Gerechnet wird auf den Dreiecksnetzen (VTK): Wie tief liegen Ecken des einen Teils im anderen, wie nah kommen sie ihm?
+ Der genaue Abstand zweier B-Rep-Koerper (BRepExtrema) brauchte bei Zahnraedern Sekunden je Paar und Zeitpunkt.
+ Genau ist das auf die doppelte Netztoleranz (`tolerance`, wie die Beruehrung in soma analyze). vtkCollisionDetection-
+ Filter (schneiden sich die Oberflaechen?) stuerzte zusammen mit vtkImplicitPolyDataDistance gelegentlich ab, deshalb
+ nur Abstaende an den Ecken der unterteilten Netze. Teile, die sich schon in der Lage im Modell beruehren (Nocken und Stoessel, Bolzen in der Bohrung), sind
+ eine gewollte Beruehrung: Kollision erst, wenn eines tiefer eindringt. Bei allen anderen entscheidet ueber eine
+ Beruehrung ohne tiefe Ecke die Schnittmenge der B-Rep-Koerper. Ebenso ist Spiel aus dem Modell, das enger als gap ist,
+ so konstruiert: "zu nah" nur, wenn es in der Bewegung enger wird."""
+ from vtkmodules.vtkCommonCore import vtkObject, vtkSMPTools
+ vtkObject.GlobalWarningDisplayOff() # OBB-Baeume melden flache Zellen als Warnung, hier kein Fehler
+ # FunctionValue rechnet mit vtkSMPTools parallel, vtkImplicitPolyDataDistance haelt aber Zwischenwerte im Objekt
+ backend = vtkSMPTools.GetBackend()
+ vtkSMPTools.SetBackend("Sequential")
+ try:
+ return _check(root, name, step, gap)
+ finally:
+ vtkSMPTools.SetBackend(backend)
+
+
+def _check(root, name, step, gap):
+ from scipy.spatial import cKDTree
+ from vtkmodules.vtkFiltersCore import vtkImplicitPolyDataDistance
+ from . import mesher
+ from .analysis import _polydata, _subdivide
+ from .progress import Progress
+ t_start = time.perf_counter()
root = Path(root).resolve()
entry = ensure(root, name)
parts, results = load(root, root / entry["file"])
a = next((x for _f, res in results if not isinstance(res, build.BuildError) for x in res if x.id == entry["id"]), None)
if a is None:
raise AnimError(f"Die Animation {name!r} liess sich nicht neu laden.")
- shapes = {p["name"]: p["shape"] for p in parts}
- info = {p["name"]: p for p in anim._PARTS}
+ tol = build.auto_tolerance([p["shape"] for p in parts])
+ pen = round(max(0.01, 2 * tol), 4)
+ raw = {p["name"]: mesher.mesh_shape(p["shape"], tol, 0.3) for p in parts}
+ raw = {n: m for n, m in raw.items() if m["indices"].size}
+ lo_all = np.min([m["positions"].min(axis=0) for m in raw.values()], axis=0)
+ hi_all = np.max([m["positions"].max(axis=0) for m in raw.values()], axis=0)
+ # Gemessen wird an den Ecken der Netze. Lange Kanten werden deshalb unterteilt: Eine Welle durch eine Wand haette sonst
+ # nur Ecken an ihren Enden, keine davon laege in der Wand. Aufloesung `resolution`, wie die Messstellen von soma analyze.
+ res_h = max(float(np.linalg.norm(hi_all - lo_all)) / 100, 0.2)
+ meshes = {}
+ for n, m in raw.items():
+ pos, _nrm, idx = _subdivide(m["positions"].astype(float), m["normals"].astype(float), m["indices"].astype(np.int64), res_h, 60000)
+ f = vtkImplicitPolyDataDistance()
+ f.SetInput(_polydata(m["positions"].astype(float), m["indices"].astype(np.int64)))
+ pos = np.unique(pos, axis=0)
+ meshes[n] = dict(pos=pos, tree=cKDTree(pos), lo=pos.min(0), hi=pos.max(0), dist=f,
+ shape=next(p["shape"] for p in parts if p["name"] == n))
+
duration = a.duration
- times = set(np.round(np.arange(0.0, duration + 1e-9, max(step, 0.01)), 4).tolist())
+ step = max(float(step), 0.01)
+ times = set(np.round(np.arange(0.0, duration + 1e-9, step), 4).tolist())
+ times.add(round(duration, 4))
for s in a.steps:
- times.update((round(s["start"], 4), round(s["end"], 4)))
+ # Endlagen laengerer Bewegungen zusaetzlich, nicht jede Grenze vieler kleiner Schritte (Schleifen mit play())
+ if s["end"] - s["start"] >= max(0.5, 3 * step):
+ times.update((round(s["start"], 4), round(s["end"], 4)))
times = sorted(t for t in times if 0 <= t <= duration + 1e-9)
joint_of = a.part_joint()
- moving = a.moving_parts()
+ moving = [n for n in a.moving_parts() if n in meshes]
pairs = []
for i, m in enumerate(moving):
- for o in shapes:
- if o == m or joint_of.get(o) is joint_of[m] or (o in joint_of and moving.index(o) < i):
+ for o in meshes:
+ if o == m or joint_of.get(o) is joint_of[m] or (o in moving and moving.index(o) < i):
continue
pairs.append((m, o))
- corners = {n: _corners(info[n]["bbox"]) for n in shapes}
eye = np.eye(4)
+ margin = max(gap, pen) + tol
+ # Jede Stelle der Oberflaeche liegt hoechstens res_h von einer Ecke entfernt. Ecken, die weiter als reach von allen
+ # Ecken des anderen Teils liegen, sind weiter als margin von ihm weg oder liegen tief in ihm. Tief drin heisst: Es gibt
+ # auch Ecken naeher am Rand mit mehr als pen Tiefe. Nur die uebrigen bekommen den (teuren) Abstand ueber VTK.
+ reach = margin + 2 * res_h
+ cache, volumes = {}, {}
+
+ def near(pts, other):
+ if not len(pts):
+ return pts
+ dd, _ = meshes[other]["tree"].query(pts, distance_upper_bound=reach)
+ return pts[np.isfinite(dd)]
+
+ def measure(m, o, R):
+ """R: Lage von m im System von o. Liefert (tiefste Ecke im anderen Teil, kleinster Abstand einer Ecke zum anderen
+ Teil) oder None, wenn die Teile weiter als margin auseinander liegen."""
+ A, B = meshes[m], meshes[o]
+ c = (R @ _corners((A["lo"], A["hi"])).T).T[:, :3]
+ lo, hi = np.maximum(c.min(0), B["lo"]) - margin, np.minimum(c.max(0), B["hi"]) + margin
+ if np.any(lo > hi):
+ return None
+ key = (m, o, np.round(R[:3], 5).tobytes()) # gleiche Relativlage (Pause, gleichlaeufige Teile): einmal rechnen
+ if key in cache:
+ return cache[key]
+ pa = A["pos"] @ R[:3, :3].T + R[:3, 3]
+ pb = B["pos"]
+ Ri = np.linalg.inv(R)
+ pa = near(pa[np.all((pa >= lo) & (pa <= hi), axis=1)], o)
+ pb = near(pb[np.all((pb >= lo) & (pb <= hi), axis=1)] @ Ri[:3, :3].T + Ri[:3, 3], m)
+ d = np.concatenate([_signed(B["dist"], pa), _signed(A["dist"], pb)])
+ if not len(d):
+ cache[key] = res = (0.0, margin)
+ else:
+ low = float(d.min())
+ cache[key] = res = (max(0.0, -low), max(0.0, low))
+ return res
+
+ def overlap(m, o, ma, mb):
+ """Schnittmenge der B-Rep-Koerper: (Volumen, Dicke). Die Dicke 2 V / Flaeche ist bei einem flachen Span an einer
+ Beruehrflaeche die Eindringtiefe, sie unterscheidet Rechenrauschen von echter Ueberschneidung besser als das Volumen."""
+ key = (m, o, np.round(ma[:3], 5).tobytes(), np.round(mb[:3], 5).tobytes())
+ if key not in volumes:
+ sa = meshes[m]["shape"].moved(_location(ma)) if ma is not eye else meshes[m]["shape"]
+ sb = meshes[o]["shape"].moved(_location(mb)) if mb is not eye else meshes[o]["shape"]
+ try:
+ common = sa.intersect(sb)
+ vol, area = common.Volume(), common.Area()
+ volumes[key] = (vol, 2 * vol / area if area > 1e-9 else 0.0)
+ except Exception:
+ volumes[key] = (float("nan"), float("nan"))
+ return volumes[key]
+
+ def judge(m, o, R, ma, mb, rest):
+ """("Kollision" | "zu nah" | None, Messwerte) fuer ein Paar in einer Lage. rest: kleinster Abstand in der Lage im
+ Modell (0 bei gewollter Beruehrung). Gemeldet wird nur, was in der Bewegung schlechter wird als dort."""
+ wanted = rest <= pen
+ r = measure(m, o, R)
+ if r is None:
+ return None, None
+ depth, dist = r
+ hit = dict(distance=round(dist, 4), depth=round(depth, 4))
+ if depth > pen:
+ return "Kollision", hit
+ if dist <= pen and not wanted:
+ # Beruehrung oder flaches Eindringen, keine Ecke liegt tief im anderen Teil: die B-Rep-Koerper entscheiden
+ vol, thick = overlap(m, o, ma, mb)
+ if math.isnan(vol) or (vol > VOL_MIN and thick > pen):
+ hit["volume"] = None if math.isnan(vol) else round(vol, 4)
+ hit["depth"] = round(max(depth, 0.0 if math.isnan(thick) else thick), 4)
+ return "Kollision", hit
+ # Wie bei soma analyze: Werte innerhalb der Genauigkeit um den Grenzwert gelten als genau auf dem Grenzwert
+ if gap > 0 and dist < gap - pen and dist < rest - pen:
+ return "zu nah", hit
+ return None, hit
+
+ # Lage im Modell: Beruehrung und Spiel dort sind so konstruiert, eine Kollision dort meldet die Pruefung als schon vorhanden
+ rest, at_rest = {}, {}
+ for m, o in pairs:
+ kind, hit = judge(m, o, eye, eye, eye, math.inf)
+ at_rest[(m, o)] = kind if kind == "Kollision" else None
+ rest[(m, o)] = math.inf if hit is None or kind == "Kollision" else hit["distance"]
+ progress = Progress("soma anim check", len(times), "Zeitpunkten")
found = {}
for t in times:
poses = a.poses(t)
- locs = {}
for m, o in pairs:
ma, mb = poses.get(m, eye), poses.get(o, eye)
- ca, cb = (ma @ corners[m].T).T[:, :3], (mb @ corners[o].T).T[:, :3]
- lo, hi = np.maximum(ca.min(0), cb.min(0)), np.minimum(ca.max(0), cb.max(0))
- if np.any(lo - hi > gap + 1e-6):
- continue
- for n, mm in ((m, ma), (o, mb)):
- if n not in locs:
- locs[n] = shapes[n].moved(_location(mm)) if mm is not eye else shapes[n]
- sa, sb = locs[m], locs[o]
- dist = BRepExtrema_DistShapeShape(sa.wrapped, sb.wrapped)
- d = dist.Value() if dist.IsDone() else float("nan")
- vol = 0.0
- if d <= 1e-6:
- try:
- vol = sa.intersect(sb).Volume()
- except Exception:
- vol = float("nan")
- if vol > 1e-3 or (gap > 0 and d < gap) or math.isnan(vol):
- found.setdefault((m, o), []).append(dict(t=t, distance=round(d, 4), volume=round(vol, 4)))
+ kind, hit = judge(m, o, np.linalg.inv(mb) @ ma, ma, mb, rest[(m, o)])
+ if kind:
+ found.setdefault((m, o), []).append(dict(t=t, kind=kind, **hit))
+ progress.step()
+ progress.finish()
+ index = {t: i for i, t in enumerate(times)}
out = []
for (m, o), hits in found.items():
ranges, cur = [], None
for h in hits:
- kind = "Kollision" if h["volume"] > 1e-3 or math.isnan(h["volume"]) else "zu nah"
- if cur and cur["kind"] == kind and abs(times.index(h["t"]) - times.index(cur["end"])) == 1:
+ if cur and cur["kind"] == h["kind"] and index[h["t"]] - index[cur["end"]] == 1:
cur["end"] = h["t"]
- cur["volume"] = max(cur["volume"], h["volume"])
+ cur["depth"] = max(cur["depth"], h["depth"])
cur["distance"] = min(cur["distance"], h["distance"])
+ if h.get("volume") is not None:
+ cur["volume"] = max(cur.get("volume") or 0.0, h["volume"])
else:
- cur = dict(kind=kind, start=h["t"], end=h["t"], volume=h["volume"], distance=h["distance"])
+ cur = dict(kind=h["kind"], start=h["t"], end=h["t"], depth=h["depth"], distance=h["distance"], volume=h.get("volume"))
ranges.append(cur)
- out.append(dict(a=m, b=o, atRest=hits[0]["t"] == 0, ranges=ranges))
- res = dict(version=1, id=entry["id"], name=a.name, step=step, gap=gap, checked=time.time(), samples=len(times), pairs=out)
+ out.append(dict(a=m, b=o, atRest=at_rest[(m, o)] is not None and any(r["kind"] == at_rest[(m, o)] for r in ranges),
+ ranges=ranges))
+ res = dict(version=2, id=entry["id"], name=a.name, step=step, gap=gap, tolerance=pen, checked=time.time(),
+ samples=len(times), seconds=round(time.perf_counter() - t_start, 1), pairs=out,
+ contacts=[[m, o] for m, o in pairs if rest[(m, o)] <= pen],
+ clearances=[[m, o, round(rest[(m, o)], 3)] for m, o in pairs if pen < rest[(m, o)] < gap - pen])
(root / OUT_DIR / f"{entry['id']}.check.json").write_text(json.dumps(res, indent=1, ensure_ascii=False), encoding="utf-8")
return res
@@ -545,14 +752,27 @@ def read_check(root, entry):
def check_text(res):
- head = f"Kollisionen (Schritt {res['step']:g} s, {res['samples']} Zeitpunkte" + (f", Mindestabstand {res['gap']:g} mm" if res["gap"] else "") + "):"
- if not res["pairs"]:
- return head + " keine"
- lines = [head]
+ tol = res.get("tolerance")
+ head = (f"Kollisionen (Schritt {res['step']:g} s, {res['samples']} Zeitpunkte" + (f", Mindestabstand {res['gap']:g} mm" if res["gap"] else "")
+ + (f", genau auf {tol:g} mm" if tol else "") + "):")
+ lines = [head + ("" if res["pairs"] else " keine")]
for p in res["pairs"]:
- note = " (schon in der Lage im Modell)" if p["atRest"] else ""
+ note = " (auch in der Lage im Modell)" if p["atRest"] else ""
for r in p["ranges"]:
span = f"{_t(r['start'])}-{_t(r['end'])} s" if r["end"] > r["start"] else f"{_t(r['start'])} s"
- val = f"Ueberschneidung bis {r['volume']:.3f} mm3" if r["kind"] == "Kollision" else f"Abstand bis {r['distance']:.3f} mm"
+ if r["kind"] != "Kollision":
+ val = f"Abstand bis {r['distance']:.3f} mm"
+ elif r.get("depth"):
+ val = f"bis {r['depth']:.2f} mm tief" + (f", Ueberschneidung {r['volume']:.3f} mm3" if r.get("volume") else "")
+ else:
+ val = f"Ueberschneidung bis {r['volume']:.3f} mm3" if r.get("volume") else "Oberflaechen schneiden sich"
lines.append(f" {span:<16} {p['a']} / {p['b']}: {r['kind']}, {val}{note}")
+ contacts = res.get("contacts") or []
+ if contacts:
+ names = ", ".join(f"{m} / {o}" for m, o in contacts[:6]) + (f" und {len(contacts) - 6} weitere" if len(contacts) > 6 else "")
+ lines.append(f"Beruehren sich schon im Modell (gewollt, gemeldet wird nur tieferes Eindringen): {names}")
+ near = res.get("clearances") or []
+ if near:
+ names = ", ".join(f"{m} / {o} {d:.2f} mm" for m, o, d in near[:6]) + (f" und {len(near) - 6} weitere" if len(near) > 6 else "")
+ lines.append(f"Schon im Modell naeher als {res['gap']:g} mm (gemeldet nur, wenn es enger wird): {names}")
return "\n".join(lines)
diff --git a/python/soma/build.py b/python/soma/build.py
index 4f4527b..7c6f6dc 100644
--- a/python/soma/build.py
+++ b/python/soma/build.py
@@ -70,6 +70,11 @@ def _is_inside(path, root):
return False
+# Einstiegspunkt und Namensraum des letzten erfolgreichen run_model(). Animationen importieren daraus (`from model import
+# ...`), statt das ganze Modell ein zweites Mal auszufuehren (animrun._run_file).
+LAST_RUN = None
+
+
def run_model(root, entry=None):
"""Fuehrt den Einstiegspunkt aus und liefert die registrierten Bauteile."""
root = Path(root).resolve()
@@ -79,12 +84,14 @@ def run_model(root, entry=None):
raise BuildError(
f"Einstiegspunkt {entry!r} nicht gefunden. Lege {DEFAULT_ENTRY} an oder setze \"entry\" in .soma/project.json.",
kind="EntryMissing")
+ global LAST_RUN
registry.REGISTRY.clear()
+ LAST_RUN = None
old_cwd = os.getcwd()
os.chdir(root)
sys.path.insert(0, str(root))
try:
- runpy.run_path(str(script), run_name="__main__")
+ LAST_RUN = (script, runpy.run_path(str(script), run_name="__main__"))
except BuildError:
raise
except SystemExit as e:
diff --git a/python/soma/cli.py b/python/soma/cli.py
index 18eccd2..dff16cf 100644
--- a/python/soma/cli.py
+++ b/python/soma/cli.py
@@ -104,7 +104,8 @@ def cmd_export(args):
path = out_dir / f"{p['step_name']}.{fmt}"
try:
_export_one(p["shape"], fmt, path)
- print(f"exportiert: {path.relative_to(root).as_posix()}")
+ # Im Projekt relativ (so liest es der Agent), ein Ziel ausserhalb (Speicherdialog der App) absolut
+ print(f"exportiert: {path.relative_to(root).as_posix() if path.is_relative_to(root) else path.as_posix()}")
except Exception as e:
print(f"Export von {p['name']!r} als {fmt} fehlgeschlagen: {type(e).__name__}: {e}", file=sys.stderr)
return 1
@@ -258,7 +259,7 @@ def main(argv=None):
g.add_argument("part", nargs="?", help="Name des Bauteils")
g.add_argument("--all", action="store_true", help="alle Bauteile (ohne Referenz- und Zukaufteile)")
e.add_argument("--format", required=True, help=", ".join(EXPORT_FORMATS))
- e.add_argument("--out", help="Zielordner relativ zum Projekt (Standard: exports)")
+ e.add_argument("--out", help="Zielordner, relativ zum Projekt oder absolut (Standard: exports)")
e.add_argument("--project", default=".")
e.set_defaults(func=cmd_export)
@@ -279,7 +280,7 @@ def main(argv=None):
z = sub.add_parser("analyze", help="Auswertung: overhang (3D-Druck), thickness (Wandstaerke), clearance (Spalt zu anderen Teilen)")
z.add_argument("kind", choices=["overhang", "thickness", "clearance", "list"])
- z.add_argument("--parts", help="Bauteile oder Gruppen, mit Komma getrennt (Standard: alle eigenen Teile)")
+ z.add_argument("--parts", help="Bauteile oder Gruppen, mit Komma getrennt, \"Gruppe/\" immer die Gruppe (Standard: alle eigenen Teile)")
z.add_argument("--threshold", type=float, help="Grenzwert (Standard: overhang 45 Grad, thickness 1.2 mm, clearance 0.5 mm)")
z.add_argument("--up", default="z", help="overhang: Druckrichtung (z, -z, x, -x, y, -y)")
z.add_argument("--name", help="Name des Ergebnisses (Standard: wie die Auswertung)")
diff --git a/python/soma/fasteners.py b/python/soma/fasteners.py
index 4b617bb..6d8f4f1 100644
--- a/python/soma/fasteners.py
+++ b/python/soma/fasteners.py
@@ -12,11 +12,13 @@ ins Material (Standard "-Z": von oben nach unten). Eine Schraube liegt mit der K
Scheibe mit einer Stirnseite. Senkschraube, Gewindestift und Gewindeeinsatz schliessen mit ihrer Oberseite an `at` ab.
`sunk=True` versenkt Kopf, Mutter oder Scheibe buendig (die Aussenseite liegt dann an `at`), `sunk=0.5` 0,5 mm tiefer.
`on=teil` sucht die Auflage selbst: Die Gerade durch `at` in Richtung `direction` trifft das Teil, der erste Treffer
-gilt (bei "-Z" zaehlen dann nur x und y von `at`).
+gilt (bei "-Z" zaehlen dann nur x und y von `at`). `rotate()`, `translate()` und `moved()` wie bei CadQuery-Formen
+liefern eine bewegte Kopie, etwa damit eine Schraube mit ihrem Teil in eine andere Stellung wandert.
Die Masse stammen aus den Tabellen von bd_warehouse (Apache 2.0, siehe data/fasteners/QUELLE.md), teils Nenn-, teils
Groesstmasse. Gewinde werden nicht modelliert: Schaft und Bohrung der Mutter haben den Nenndurchmesser.
"""
+import copy
import csv
import functools
import math
@@ -26,7 +28,7 @@ from pathlib import Path
import cadquery as cq
from OCP.BRepIntCurveSurface import BRepIntCurveSurface_Inter
-from OCP.gp import gp_Dir, gp_Lin, gp_Pnt
+from OCP.gp import gp_Ax1, gp_Dir, gp_Lin, gp_Pnt, gp_Trsf
__all__ = ["Screw", "Nut", "Washer", "HeatSetInsert", "lengths", "pick_length", "standards"]
@@ -409,6 +411,44 @@ class _Part:
def __soma_shape__(self):
return self.shape
+ # Lage aendern wie bei CadQuery-Formen: liefert eine Kopie, Bezeichnung, Masse und Bohrungen bleiben. So wandert eine
+ # Schraube mit ihrem Teil (etwa in eine andere Stellung), ohne sie dort neu anzulegen.
+
+ def moved(self, loc):
+ """Kopie, um loc (cq.Location) bewegt, wie cq.Shape.moved()."""
+ if not isinstance(loc, cq.Location):
+ raise ValueError(f"moved() erwartet eine cq.Location, nicht {loc!r}")
+ t = loc.wrapped.Transformation()
+
+ def pnt(v):
+ p = gp_Pnt(*v.toTuple()).Transformed(t)
+ return cq.Vector(p.X(), p.Y(), p.Z())
+
+ def dirn(v):
+ d = gp_Dir(*v.toTuple()).Transformed(t)
+ return cq.Vector(d.X(), d.Y(), d.Z())
+
+ new = copy.copy(self)
+ new._plane = cq.Plane(origin=pnt(self._plane.origin), xDir=dirn(self._plane.xDir), normal=dirn(self._plane.zDir))
+ new._loc = cq.Location(new._plane)
+ new._dir, new._surface = dirn(self._dir), pnt(self._surface)
+ return new
+
+ def translate(self, vector):
+ """Kopie, um vector (x, y, z) verschoben, wie cq.Shape.translate()."""
+ return self.moved(cq.Location(_vec(vector, "translate")))
+
+ def rotate(self, startVector, endVector, angleDegrees):
+ """Kopie, um die Achse von startVector nach endVector gedreht (Grad), wie cq.Shape.rotate()."""
+ p1, p2 = _vec(startVector, "rotate: startVector"), _vec(endVector, "rotate: endVector")
+ if (p2 - p1).Length < 1e-9:
+ raise ValueError("rotate: startVector und endVector muessen verschieden sein (sie legen die Achse fest)")
+ if not isinstance(angleDegrees, numbers.Real):
+ raise ValueError(f"rotate: Winkel in Grad, nicht {angleDegrees!r}")
+ t = gp_Trsf()
+ t.SetRotation(gp_Ax1(gp_Pnt(*p1.toTuple()), gp_Dir(*(p2 - p1).toTuple())), math.radians(angleDegrees))
+ return self.moved(cq.Location(t))
+
def __repr__(self):
return f"<{self.designation} an {_pt(cq.Vector(*self.seat))}, Richtung {_pt(self._dir)}>"
diff --git a/python/soma/progress.py b/python/soma/progress.py
new file mode 100644
index 0000000..902f038
--- /dev/null
+++ b/python/soma/progress.py
@@ -0,0 +1,44 @@
+"""Fortschritt fuer lange Befehle (anim check, analyze).
+
+Ein Agent sieht sonst minutenlang nichts und kann nicht unterscheiden, ob der Befehl arbeitet oder haengt. Die Zeilen
+gehen in den Fehlerkanal, damit die eigentliche Ausgabe auf stdout unveraendert bleibt. Kurze Laeufe bleiben still:
+die erste Zeile kommt erst nach `after` Sekunden, danach hoechstens alle `every` Sekunden eine.
+"""
+import sys
+import time
+
+
+def _dur(s):
+ if s < 90:
+ return f"{max(1, round(s))} s"
+ return f"{round(s / 60)} min"
+
+
+class Progress:
+ def __init__(self, what, total, unit="Schritte", after=5.0, every=15.0):
+ self.what, self.total, self.unit = what, max(1, int(total)), unit
+ self.after, self.every = after, every
+ self.done = 0
+ self.start = time.perf_counter()
+ self.last = None
+
+ def step(self, n=1):
+ self.done = min(self.total, self.done + n)
+ now = time.perf_counter()
+ elapsed = now - self.start
+ if elapsed < self.after or (self.last is not None and now - self.last < self.every) or self.done >= self.total:
+ return
+ self.last = now
+ rest = elapsed / max(self.done, 1) * (self.total - self.done)
+ self._say(f"{self.what}: {self.done} von {self.total} {self.unit}, noch etwa {_dur(rest)}")
+
+ def finish(self):
+ if self.last is not None:
+ self._say(f"{self.what}: fertig nach {_dur(time.perf_counter() - self.start)}")
+
+ @staticmethod
+ def _say(text):
+ try:
+ print(text, file=sys.stderr, flush=True)
+ except (OSError, ValueError):
+ pass