Desktop app for designing parametric 3D models in CadQuery together with the coding agent of your choice
TypeScript 3d-modeling3d-printing3d-printing-toolsagentagentic-aiai-cadcadcadqueryclaude-codecodexelectronfemllmmacdmakeropencodeparametric-designpythonsteptext-to-cad
soma: Animationen, Auswertungen und Bilder über die App (E58)
Kai-Jungsthoefel688298fd35a1
diff --git a/python/soma/__init__.py b/python/soma/__init__.pyindex f90703b..fcbea36 100644--- a/python/soma/__init__.py+++ b/python/soma/__init__.py@@ -1,5 +1,6 @@"""soma: Hilfsbibliothek von SOMA. Aus model.py: `from soma import add_part, import_step`.-Normteile (Schrauben, Muttern, Scheiben, Gewindeeinsaetze): `from soma.fasteners import Screw, Nut, Washer, HeatSetInsert`."""+Normteile (Schrauben, Muttern, Scheiben, Gewindeeinsaetze): `from soma.fasteners import Screw, Nut, Washer, HeatSetInsert`.+Animationen in animations/*.py: `from soma.anim import Animation`."""import time as _time# Vor dem Import von cadquery (dauert Sekunden): `soma build` meldet die ganze Wartezeit, nicht nur das Modelldiff --git a/python/soma/analysis.py b/python/soma/analysis.pynew file mode 100644index 0000000..6f09018--- /dev/null+++ b/python/soma/analysis.py@@ -0,0 +1,333 @@+"""`soma analyze`: Auswertungen am Modell mit einem Wert je Stelle der Oberflaeche (E58).++- overhang: Ueberhangwinkel fuer den 3D-Druck (0 = senkrechte Wand, 90 = waagerecht nach unten)+- thickness: Wandstaerke (Strahl von der Oberflaeche nach innen bis zur Gegenseite)+- clearance: Abstand zu den anderen Bauteilen (negativ: Ueberschneidung)++Ergebnis je Auswertung: .soma/results/<name>.glb. Jedes Bauteil ist ein Netz mit dem Attribut _VALUE (ein Wert je+Dreieck, an seinen drei Ecken), die Kanten als Linien. Die Metadaten (Groesse, Einheit, Grenzwert, Zusammenfassung)+stehen in extras.soma_result. Der Viewer faerbt danach, `soma render --result <name>` zeigt es dem Agenten als Bild.+"""+import math+import time+from pathlib import Path++import numpy as np++from . import build, gltf, mesher++OUT_DIR = Path(".soma") / "results"++KINDS = {+ "overhang": dict(title="Überhang", quantity="Überhangwinkel", unit="°", bad="high", threshold=45.0,+ help="Winkel zur Senkrechten fuer nach unten zeigende Flaechen, kritisch ueber dem Grenzwert"),+ "thickness": dict(title="Wandstärke", quantity="Wandstärke", unit="mm", bad="low", threshold=1.2,+ help="Abstand zur Gegenseite des Materials, kritisch unter dem Grenzwert"),+ "clearance": dict(title="Abstand", quantity="Abstand zu anderen Bauteilen", unit="mm", bad="low", threshold=0.5,+ help="kleinster Abstand zu einem anderen Bauteil, negativ bei Ueberschneidung, kritisch unter dem Grenzwert"),+}+++class AnalysisError(Exception):+ pass+++# ---- 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):+ 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:+ 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)+ 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)+ 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])+ return pos, nrm, idx+++def _polydata(pos, idx):+ from vtkmodules.util.numpy_support import numpy_to_vtk, numpy_to_vtkIdTypeArray+ from vtkmodules.vtkCommonCore import vtkPoints+ from vtkmodules.vtkCommonDataModel import vtkCellArray, vtkPolyData+ pts = vtkPoints()+ pts.SetData(numpy_to_vtk(np.ascontiguousarray(pos, dtype=np.float64), deep=True))+ cells = vtkCellArray()+ conn = np.ascontiguousarray(idx.reshape(-1).astype(np.int64))+ offs = np.arange(0, len(conn) + 1, 3, dtype=np.int64)+ cells.SetData(numpy_to_vtkIdTypeArray(offs, deep=True), numpy_to_vtkIdTypeArray(conn, deep=True))+ pd = vtkPolyData()+ pd.SetPoints(pts)+ pd.SetPolys(cells)+ return pd+++# ---- Auswertungen -----------------------------------------------------------------------------------------------++def _overhang(tri, normals, up):+ d = np.clip(-(normals @ up), -1.0, 1.0)+ angle = np.degrees(np.arcsin(np.clip(d, 0.0, 1.0)))+ # Flaechen, die auf dem Druckbett liegen, sind kein Ueberhang (unterste Ebene in Druckrichtung)+ h = tri @ up+ low = h.min()+ tol = max(1e-3, (h.max() - low) * 1e-4)+ bed = (angle > 89.0) & np.all(h <= low + tol, axis=1)+ angle[bed] = 0.0+ return angle+++def _thickness(tri, normals, own_pd, diag):+ from vtkmodules.vtkCommonCore import vtkIdList, vtkPoints+ from vtkmodules.vtkFiltersGeneral import vtkOBBTree+ tree = vtkOBBTree()+ tree.SetDataSet(own_pd)+ tree.BuildLocator()+ eps = max(1e-4, diag * 1e-5)+ length = diag * 1.5+ 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+ pts.Reset()+ if tree.IntersectWithLine(p0, p1, pts, ids) == 0 or pts.GetNumberOfPoints() == 0:+ continue+ 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+ if best < math.inf:+ out[i] = best + eps+ return out+++def _clearance(tri, normals, others_pd, limit, contact):+ """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."""+ from vtkmodules.vtkCommonCore import vtkIdList, vtkPoints+ from vtkmodules.vtkFiltersCore import vtkImplicitPolyDataDistance+ from vtkmodules.vtkFiltersGeneral import vtkOBBTree+ f = vtkImplicitPolyDataDistance()+ f.SetInput(others_pd)+ tree = vtkOBBTree()+ tree.SetDataSet(others_pd)+ tree.BuildLocator()+ cen = tri.mean(axis=1)+ eps = contact * 0.5+ pts, ids = vtkPoints(), vtkIdList()+ out = np.full(len(cen), float(limit))+ for i in range(len(cen)):+ sd = f.EvaluateFunction(cen[i])+ if sd < -contact:+ out[i] = max(sd, -limit)+ continue+ if abs(sd) <= contact:+ out[i] = 0.0+ continue+ if sd >= limit:+ continue+ p0 = cen[i] + normals[i] * eps+ pts.Reset()+ if tree.IntersectWithLine(p0, cen[i] + normals[i] * limit, pts, ids) and pts.GetNumberOfPoints():+ out[i] = min(math.dist(pts.GetPoint(k), cen[i]) for k in range(pts.GetNumberOfPoints()))+ return out+++# ---- Ablauf -----------------------------------------------------------------------------------------------------++def _pick(parts, spec, default_roles):+ if not spec:+ return [p for p in parts if p["role"] in default_roles]+ out = []+ 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 + "/")]+ 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}")+ out += [p for p in hit if p not in out]+ return out+++def _fmt(v, unit):+ v = v + 0.0 # kein "-0.0"+ return f"{v:.1f}{unit}" if unit == "°" else f"{v:.2f} {unit}"+++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."""+ if kind not in KINDS:+ raise AnalysisError(f"Unbekannte Auswertung {kind!r}. Moeglich: {', '.join(KINDS)}")+ spec = KINDS[kind]+ 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",))+ 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)+ 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)+ hi = np.max([m["positions"].max(axis=0) for m in meshes.values() if len(m["positions"])], axis=0)+ diag_all = float(np.linalg.norm(hi - lo))+ 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)+ if kind == "clearance" and len(parts) < 2:+ raise AnalysisError("Der Abstand braucht mindestens zwei Bauteile.")+ g = gltf.Glb()+ edge_mat = g.material(name="edge", pbrMetallicRoughness=dict(baseColorFactor=[0.05, 0.05, 0.05, 1.0], metallicFactor=0, roughnessFactor=1))+ 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()+ for i, p in enumerate(parts):+ if p not in chosen:+ continue+ m = meshes[p["name"]]+ if 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)+ 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)+ elif kind == "thickness":+ diag = float(np.linalg.norm(pos.max(axis=0) - pos.min(axis=0)))+ vals = _thickness(tri, fn, _polydata(pos, idx), diag)+ else:+ from vtkmodules.vtkFiltersCore import vtkAppendPolyData+ app = vtkAppendPolyData()+ for q in parts:+ if q is not p and meshes[q["name"]]["indices"].size:+ 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)+ valid = ~np.isnan(vals)+ if kind == "thickness":+ vals = np.where(valid, vals, np.nan)+ crit = (vals > thr) if spec["bad"] == "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),+ critical=round(float(area[crit].sum()), 3), triangles=int(len(idx2)))+ 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))+ st["worst"] = dict(value=round(float(vals[w]), 4), at=[round(float(x), 3) for x in tri[w].mean(axis=0)])+ 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())+ stats.append(st)+ # Je Dreieck drei eigene Ecken: der Wert gilt fuer das ganze Dreieck+ flat_pos = tri.reshape(-1, 3)+ flat_nrm = nrm2[idx2].reshape(-1, 3)+ flat_val = np.repeat(np.nan_to_num(vals, nan=-1.0 if spec["bad"] == "low" else 0.0), 3)+ prims = [dict(mode=4, material=face_mat, attributes=dict(+ POSITION=g.accessor(flat_pos, "VEC3", gltf.ARRAY_BUFFER, True), NORMAL=g.accessor(flat_nrm, "VEC3", gltf.ARRAY_BUFFER),+ _VALUE=g.accessor(flat_val, "SCALAR", gltf.ARRAY_BUFFER)))]+ if m["lines"].size:+ prims.append(dict(mode=1, material=edge_mat, attributes=dict(POSITION=g.accessor(m["lines"], "VEC3", gltf.ARRAY_BUFFER, True))))+ 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))))+ seconds = time.perf_counter() - t_start+ unit = spec["unit"]+ if kind == "overhang":+ rng = [0.0, 90.0]+ elif kind == "thickness":+ rng = [0.0, round(max(3 * thr, 1.0), 3)]+ else:+ 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,+ 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)+ out = root / OUT_DIR+ out.mkdir(parents=True, exist_ok=True)+ path = out / f"{rid}.glb"+ tmp = path.with_suffix(".glb.part")+ g.write(tmp, [g.node(name="soma-result", children=children)], extras=dict(soma_result=meta))+ gltf.replace(tmp, path)+ meta["file"] = path.relative_to(root).as_posix()+ return meta+++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)"+ if meta["kind"] == "overhang":+ head += f", Druckrichtung +{meta['up'].lstrip('-')}" if not (meta["up"] or "").startswith("-") else f", Druckrichtung {meta['up']}"+ lines = [head + ":"]+ for st in meta["parts"]:+ if "min" not in st:+ lines.append(f" {st['name']}: keine Werte")+ continue+ 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("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 ""+ lines.append(f" {st['name']}: {rng}, {crit}{extra}{worst}")+ return "\n".join(lines)+++def list_results(root):+ out = []+ d = Path(root) / OUT_DIR+ for p in sorted(d.glob("*.glb")) if d.is_dir() else []:+ try:+ meta = gltf.read_json(p)["extras"]["soma_result"]+ meta["file"] = p.relative_to(Path(root)).as_posix()+ out.append(meta)+ except (OSError, ValueError, KeyError):+ continue+ return out+++def find(root, name):+ return next((m for m in list_results(root) if name in (m["id"], m["title"], m["kind"])), None)diff --git a/python/soma/anim.py b/python/soma/anim.pynew file mode 100644index 0000000..0c5fe8e--- /dev/null+++ b/python/soma/anim.py@@ -0,0 +1,569 @@+"""Animationen (E58): Bewegungen, Kamerafahrten und Texte, beschrieben in animations/*.py.++Der Agent beschreibt eine Animation in Python, aehnlich wie in manim (`play`, `wait`, `run_time`) und mit Drehachsen wie+in CadQuery (`rotate(p1, p2, winkel)`). `soma anim build` fuehrt die Datei aus, tastet die Bewegung ab und schreibt eine+glTF-Animation nach .soma/anim/. Viewer, Video und Bilder entstehen daraus, die Animation selbst ist kein Video.++ from soma.anim import Animation++ a = Animation("Deckel oeffnen")+ lid = a.hinge("Deckel", (0, 20, 25), (1, 20, 25)) # Drehachse durch zwei Punkte, wie cq rotate()+ a.camera.set(view="iso")+ a.caption("Der Deckel oeffnet bis 110 Grad")+ a.play(lid.to(110), run_time=2)+ a.play(a.camera.orbit(90), run_time=3)++Laengen in mm, Winkel in Grad, Zeiten in Sekunden. Bauteile heissen wie in add_part(), Gruppen wie in group=.+"""+import inspect+import math++import numpy as np++from . import registry++ANIMATIONS = [] # fuellt sich beim Ausfuehren einer Animationsdatei (siehe animrun.py)+_PARTS = None # Bauteile des Modells: Liste von dict(name, group, bbox), setzt animrun.py+SAMPLE_FPS = 30 # Abtastung der Bewegung, der Viewer interpoliert dazwischen+FOV = 35.0 # senkrechter Bildwinkel in Grad, wie im Viewer+MAX_TEXT = 300++VIEWS = {+ "iso": (0.8, -1.2, 0.9), "front": (0, -1, 0), "back": (0, 1, 0), "top": (0, -0.0001, 1),+ "bottom": (0, -0.0001, -1), "right": (1, 0, 0), "left": (-1, 0, 0),+}+++def _cubic_in_out(s):+ return 4 * s ** 3 if s < 0.5 else 1 - (-2 * s + 2) ** 3 / 2+++EASES = {+ "linear": lambda s: s,+ "smooth": _cubic_in_out,+ "in_out": _cubic_in_out,+ "in": lambda s: s ** 3,+ "out": lambda s: 1 - (1 - s) ** 3,+}+++def _ease(ease):+ if callable(ease):+ return ease+ if ease not in EASES:+ raise ValueError(f"ease={ease!r} gibt es nicht. Moeglich: {', '.join(EASES)} oder eine Funktion f(s) fuer s von 0 bis 1")+ return EASES[ease]+++# ---- Mathematik (4x4-Matrizen, Quaternionen x, y, z, w wie in glTF) ---------------------------------------------------++def _vec(v, what):+ try:+ a = np.asarray([float(x) for x in v], dtype=float)+ except (TypeError, ValueError):+ raise ValueError(f"{what} muss drei Zahlen haben, z. B. (0, 0, 10), nicht {v!r}") from None+ if a.shape != (3,) or not np.all(np.isfinite(a)):+ raise ValueError(f"{what} muss drei Zahlen haben, z. B. (0, 0, 10), nicht {v!r}")+ return a+++def _unit(v, what):+ v = _vec(v, what)+ n = np.linalg.norm(v)+ if n < 1e-12:+ raise ValueError(f"{what} darf nicht die Laenge 0 haben")+ return v / n+++def _translation(v):+ m = np.eye(4)+ m[:3, 3] = v+ return m+++def _rotation(axis, deg):+ """Drehung um eine Achse durch den Ursprung (Rodrigues)."""+ x, y, z = axis+ a = math.radians(deg)+ c, s, t = math.cos(a), math.sin(a), 1 - math.cos(a)+ m = np.eye(4)+ m[:3, :3] = [[t * x * x + c, t * x * y - s * z, t * x * z + s * y],+ [t * x * y + s * z, t * y * y + c, t * y * z - s * x],+ [t * x * z - s * y, t * y * z + s * x, t * z * z + c]]+ return m+++def _axis_rotation(p1, axis, deg):+ """Drehung um die Gerade durch p1 mit Richtung axis."""+ return _translation(p1) @ _rotation(axis, deg) @ _translation(-p1)+++def _quat(m):+ """Quaternion (x, y, z, w) aus der Drehung einer 4x4-Matrix."""+ r = m[:3, :3]+ tr = r[0, 0] + r[1, 1] + r[2, 2]+ if tr > 0:+ s = math.sqrt(tr + 1.0) * 2+ q = ((r[2, 1] - r[1, 2]) / s, (r[0, 2] - r[2, 0]) / s, (r[1, 0] - r[0, 1]) / s, 0.25 * s)+ elif r[0, 0] > r[1, 1] and r[0, 0] > r[2, 2]:+ s = math.sqrt(1.0 + r[0, 0] - r[1, 1] - r[2, 2]) * 2+ q = (0.25 * s, (r[0, 1] + r[1, 0]) / s, (r[0, 2] + r[2, 0]) / s, (r[2, 1] - r[1, 2]) / s)+ elif r[1, 1] > r[2, 2]:+ s = math.sqrt(1.0 + r[1, 1] - r[0, 0] - r[2, 2]) * 2+ q = ((r[0, 1] + r[1, 0]) / s, 0.25 * s, (r[1, 2] + r[2, 1]) / s, (r[0, 2] - r[2, 0]) / s)+ else:+ s = math.sqrt(1.0 + r[2, 2] - r[0, 0] - r[1, 1]) * 2+ q = ((r[0, 2] + r[2, 0]) / s, (r[1, 2] + r[2, 1]) / s, 0.25 * s, (r[1, 0] - r[0, 1]) / s)+ q = np.asarray(q)+ return q / np.linalg.norm(q)+++def _quat_matrix(q):+ x, y, z, w = q+ return np.array([[1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)],+ [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)],+ [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)]])+++def _slerp(q0, q1, s):+ d = float(np.dot(q0, q1))+ if d < 0:+ q1, d = -q1, -d+ if d > 0.9995:+ q = q0 + (q1 - q0) * s+ return q / np.linalg.norm(q)+ th = math.acos(d)+ return (math.sin((1 - s) * th) * q0 + math.sin(s * th) * q1) / math.sin(th)+++def _blend(m0, m1, s):+ """Zwischenlage zweier Lagen: Ursprung geradlinig, Drehung auf kuerzestem Weg."""+ out = np.eye(4)+ out[:3, :3] = _quat_matrix(_slerp(_quat(m0), _quat(m1), s))+ out[:3, 3] = m0[:3, 3] + (m1[:3, 3] - m0[:3, 3]) * s+ return out+++def _placement(loc):+ """Lage als 4x4-Matrix: cq.Location, eine 4x4-Matrix oder (x, y, z) fuer eine reine Verschiebung."""+ if hasattr(loc, "wrapped") and hasattr(loc.wrapped, "Transformation"): # cq.Location+ t = loc.wrapped.Transformation()+ m = np.eye(4)+ for r in range(3):+ for c in range(4):+ m[r, c] = t.Value(r + 1, c + 1)+ return m+ a = np.asarray(loc, dtype=float) if not isinstance(loc, str) else None+ if a is not None and a.shape == (4, 4):+ return a.copy()+ return _translation(_vec(loc, "Die Lage"))+++# ---- Bauteile ---------------------------------------------------------------------------------------------------++def _parts():+ if _PARTS is None:+ raise RuntimeError("Animationen laufen ueber `soma anim build` (dort kennt soma die Bauteile des Modells), "+ "nicht direkt mit python.")+ return _PARTS+++def _resolve(spec, what="Bauteil"):+ """Bauteilname, Gruppe ("Gehaeuse" oder "Gehaeuse/Schrauben") oder eine Liste davon -> Liste von Bauteilnamen."""+ parts = _parts()+ if isinstance(spec, (list, tuple, set)):+ out = []+ for s in spec:+ for n in _resolve(s, what):+ if n not in out:+ out.append(n)+ if not out:+ raise ValueError(f"{what}: leere Liste")+ return out+ if not isinstance(spec, str) or not spec.strip():+ raise ValueError(f"{what} muss ein Bauteilname oder eine Gruppe sein, nicht {spec!r}")+ if any(p["name"] == spec for p in parts):+ return [spec]+ path = spec.strip("/")+ hit = [p["name"] for p in parts if p["group"] and ("/".join(p["group"]) == path or "/".join(p["group"]).startswith(path + "/"))]+ if hit:+ return hit+ names = ", ".join(repr(p["name"]) for p in parts[:30]) + (" ..." if len(parts) > 30 else "")+ groups = sorted({"/".join(p["group"][:i + 1]) for p in parts for i in range(len(p["group"]))})+ extra = f" Gruppen: {', '.join(repr(g) for g in groups)}." if groups else ""+ raise ValueError(f"{what} {spec!r} gibt es im Modell nicht. Bauteile: {names}.{extra}")+++def _where():+ """Datei und Zeile des Aufrufs im Projekt (fuer Fehlermeldungen und die Anzeige)."""+ frame = inspect.currentframe().f_back.f_back+ return frame.f_code.co_filename, frame.f_lineno+++def _text(text, what):+ if not isinstance(text, str):+ raise ValueError(f"{what} muss ein Text sein, nicht {type(text).__name__}")+ t = " ".join(text.split())+ if len(t) > MAX_TEXT:+ raise ValueError(f"{what} ist laenger als {MAX_TEXT} Zeichen")+ return t+++def _num(v, what, lo=None):+ try:+ f = float(v)+ except (TypeError, ValueError):+ raise ValueError(f"{what} muss eine Zahl sein, nicht {v!r}") from None+ if not math.isfinite(f) or (lo is not None and f < lo):+ raise ValueError(f"{what} muss eine Zahl{'' if lo is None else f' ab {lo}'} sein, nicht {v!r}")+ return f+++# ---- Gelenke ----------------------------------------------------------------------------------------------------++class _Action:+ """Eine Bewegung, die play() in die Zeitleiste legt. `target` ist ein Gelenk oder die Kamera."""++ def __init__(self, target, make, describe):+ self.target, self.make, self.describe = target, make, describe+++class Joint:+ """Bauteile, die sich gemeinsam bewegen. Entsteht ueber Animation.hinge(), slider() oder part()."""++ 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+ self.start = value+ self.segments = [] # (t0, t1, f(s) -> Wert, ease)+ self.label = ", ".join(parts[:3]) + (" ..." if len(parts) > 3 else "")++ def _own(self, value):+ raise NotImplementedError++ def value_at(self, t):+ v = self.start+ for t0, t1, f, ease in self.segments:+ if t >= t1:+ v = f(1.0)+ elif t >= t0:+ return f(ease((t - t0) / (t1 - t0)) if t1 > t0 else 1.0)+ else:+ break+ return v++ def matrix(self, t):+ """Lage aller Bauteile dieses Gelenks zur Zeit t (mit den Gelenken darueber)."""+ m = self._own(self.value_at(t))+ return self.parent.matrix(t) @ m if self.parent else m+++class _Hinge(Joint):+ def __init__(self, anim, parts, p1, axis, parent, angle):+ super().__init__(anim, "hinge", parts, parent, angle)+ self.p1, self.axis = p1, axis++ def _own(self, value):+ return _axis_rotation(self.p1, self.axis, value)++ def to(self, angle):+ """Auf diesen Winkel drehen (Grad, 0 = Lage im Modell)."""+ a1 = _num(angle, "Der Winkel")+ return _Action(self, lambda a0: (lambda s: a0 + (a1 - a0) * s, a1), lambda a0: f"{self.label}: {a0:g} -> {a1:g} Grad")++ def by(self, delta):+ """Um diesen Winkel weiterdrehen (Grad)."""+ d = _num(delta, "Der Winkel")+ return _Action(self, lambda a0: (lambda s: a0 + d * s, a0 + d), lambda a0: f"{self.label}: {a0:g} -> {a0 + d:g} Grad")+++class _Slider(Joint):+ def __init__(self, anim, parts, direction, parent, position):+ super().__init__(anim, "slider", parts, parent, position)+ self.direction = direction++ def _own(self, value):+ return _translation(self.direction * value)++ def to(self, distance):+ """An diese Stelle schieben (mm entlang der Richtung, 0 = Lage im Modell)."""+ d1 = _num(distance, "Der Weg")+ return _Action(self, lambda d0: (lambda s: d0 + (d1 - d0) * s, d1), lambda d0: f"{self.label}: {d0:g} -> {d1:g} mm")++ def by(self, delta):+ """Um diesen Weg weiterschieben (mm)."""+ d = _num(delta, "Der Weg")+ return _Action(self, lambda d0: (lambda s: d0 + d * s, d0 + d), lambda d0: f"{self.label}: {d0:g} -> {d0 + d:g} mm")+++class _Free(Joint):+ def __init__(self, anim, parts, parent):+ super().__init__(anim, "free", parts, parent, np.eye(4))++ def _own(self, value):+ return value++ def to(self, location):+ """In diese Lage bewegen (cq.Location oder (x, y, z), bezogen auf die Lage im Modell). Ohne Drehachse geht der+ Ursprung geradlinig: Fuer Drehungen um eine Achse hinge() oder rotate() nehmen."""+ m1 = _placement(location)+ return _Action(self, lambda m0: (lambda s: _blend(m0, m1, s), m1), lambda m0: f"{self.label}: in neue Lage")++ def translate(self, vector):+ """Um diesen Vektor verschieben (mm)."""+ v = _vec(vector, "Die Verschiebung")+ return _Action(self, lambda m0: (lambda s: _translation(v * s) @ m0, _translation(v) @ m0),+ lambda m0: f"{self.label}: verschieben um ({v[0]:g}, {v[1]:g}, {v[2]:g}) mm")++ def rotate(self, p1, p2, angle):+ """Um die Achse durch p1 und p2 drehen (Grad), wie cq rotate(). Die Achse liegt im Modell, nicht im Teil."""+ a, b = _vec(p1, "Der erste Achspunkt"), _vec(p2, "Der zweite Achspunkt")+ axis = _unit(b - a, "Die Drehachse (p2 - p1)")+ deg = _num(angle, "Der Winkel")+ return _Action(self, lambda m0: (lambda s: _axis_rotation(a, axis, deg * s) @ m0, _axis_rotation(a, axis, deg) @ m0),+ lambda m0: f"{self.label}: drehen um {deg:g} Grad")+++# ---- Kamera -----------------------------------------------------------------------------------------------------++class Camera:+ """Kamera einer Animation. set() springt, move(), orbit() und zoom() sind Bewegungen fuer play()."""++ def __init__(self, anim):+ self.anim = anim+ self.ops = [] # dict(t0, t1, kind, spec, ease)++ def _spec(self, view, fit, zoom, target, distance):+ spec = {}+ if view is not None:+ if isinstance(view, str):+ if view not in VIEWS:+ raise ValueError(f"view={view!r} gibt es nicht. Moeglich: {', '.join(VIEWS)} oder eine Richtung (x, y, z)")+ spec["dir"] = _unit(VIEWS[view], "Die Blickrichtung")+ else:+ spec["dir"] = _unit(view, "Die Blickrichtung (von der Mitte zur Kamera)")+ spec["view"] = view if isinstance(view, str) else "Richtung"+ if fit is not None:+ spec["fit"] = None if fit == "all" else _resolve(fit, "fit")+ if zoom is not None:+ spec["zoom"] = _num(zoom, "zoom", 0.01)+ if target is not None:+ spec["target"] = _vec(target, "target")+ if distance is not None:+ spec["distance"] = _num(distance, "distance", 0.01)+ return spec++ def set(self, view=None, fit=None, zoom=None, target=None, distance=None):+ """Kamera sofort setzen. view: "iso", "front", "back", "left", "right", "top", "bottom" oder eine Richtung von der+ Mitte zur Kamera. fit: Bauteile oder Gruppen, die ganz ins Bild sollen (ueber die ganze Bewegung), Standard alle.+ zoom: groesser als 1 naeher heran. target und distance setzen Mitte und Abstand (mm) direkt."""+ spec = self._spec(view, fit, zoom, target, distance)+ if "fit" not in spec and "target" not in spec and "distance" not in spec:+ spec["fit"] = None # ohne Angabe: alles einpassen+ t = self.anim.time+ self.ops.append(dict(t0=t, t1=t, kind="set", spec=spec, ease=EASES["linear"]))+ self.anim._step(t, t, "Kamera: " + _describe_camera(spec))++ def move(self, view=None, fit=None, zoom=None, target=None, distance=None):+ """Kamerafahrt zu einer neuen Ansicht (fuer play). Was nicht angegeben ist, bleibt: Ohne fit, target und distance+ bleiben Mitte und Abstand, und die Kamera schwenkt nur."""+ spec = self._spec(view, fit, zoom, target, distance)+ return _Action(self, ("move", spec), lambda _v: "Kamera: Fahrt " + _describe_camera(spec))++ def orbit(self, degrees, tilt=0.0):+ """Um die Mitte kreisen (Grad um die Hochachse Z, positiv gegen den Uhrzeigersinn von oben). tilt hebt oder+ senkt die Kamera (Grad)."""+ spec = dict(orbit=_num(degrees, "Der Winkel"), tilt=_num(tilt, "tilt"))+ return _Action(self, ("orbit", spec), lambda _v: f"Kamera: Umlauf {spec['orbit']:g} Grad" + (f", Neigung {spec['tilt']:g} Grad" if spec["tilt"] else ""))++ def zoom(self, factor):+ """Naeher heran (factor groesser als 1) oder weiter weg (kleiner als 1)."""+ f = _num(factor, "Der Faktor", 0.01)+ return _Action(self, ("zoom", dict(zoom=f)), lambda _v: f"Kamera: Zoom x{f:g}")+++def _describe_camera(spec):+ bits = []+ if "view" in spec:+ bits.append(f"Ansicht {spec['view']}")+ if "fit" in spec:+ bits.append("alles im Bild" if spec["fit"] is None else f"im Bild: {', '.join(spec['fit'][:4])}")+ if "zoom" in spec:+ bits.append(f"Zoom x{spec['zoom']:g}")+ if "target" in spec:+ bits.append("Mitte ({:g}, {:g}, {:g})".format(*spec["target"]))+ if "distance" in spec:+ bits.append(f"Abstand {spec['distance']:g} mm")+ return ", ".join(bits) or "unveraendert"+++# ---- Animation --------------------------------------------------------------------------------------------------++class Animation:+ """Eine Animation mit Namen. Mehrere je Datei sind erlaubt, Namen muessen im Projekt eindeutig sein.++ Zeitleiste wie in manim: play() bewegt (alle uebergebenen Bewegungen gleichzeitig) und rueckt die Zeit um run_time+ weiter, wait() wartet, title() zeigt eine Titelkarte und rueckt weiter. caption(), label(), highlight(), hide(),+ show() und ghost() gelten ab der aktuellen Zeit und ruecken nicht weiter.+ """++ def __init__(self, name):+ self.name = _text(name, "Der Name der Animation")+ if not self.name:+ raise ValueError("Die Animation braucht einen Namen, z. B. Animation(\"Deckel oeffnen\")")+ self.id = registry.ascii_name(self.name).lower().replace("_", "-")+ self.file, self.line = _where()+ self.time = 0.0+ self.joints, self.camera = [], Camera(self)+ self.captions, self.titles, self.labels, self.events, self.steps = [], [], [], [], []+ _parts()+ ANIMATIONS.append(self)++ # -- Gelenke --++ def _joint(self, joint):+ for j in self.joints:+ twice = set(j.parts) & set(joint.parts)+ if twice:+ raise ValueError(f"{sorted(twice)[0]!r} haengt schon an einem Gelenk dieser Animation. Ein Bauteil hat "+ "ein Gelenk, Bewegungen darueber kommen mit parent=.")+ if joint.parent is not None and not isinstance(joint.parent, Joint):+ raise ValueError("parent muss ein Gelenk dieser Animation sein (Rueckgabe von hinge(), slider() oder part())")+ self.joints.append(joint)+ return joint++ def hinge(self, parts, p1, p2, parent=None, angle=0.0):+ """Drehgelenk: Bauteile (Name, Gruppe oder Liste) drehen um die Achse durch p1 und p2, wie cq rotate(p1, p2, w).+ Positive Winkel drehen rechtsherum um die Richtung p2 - p1. angle ist der Winkel am Anfang (Grad, 0 = wie im+ Modell). parent: Gelenk, auf dem dieses sitzt (die Achse liegt dann in der Modelllage)."""+ a, b = _vec(p1, "Der erste Achspunkt"), _vec(p2, "Der zweite Achspunkt")+ return self._joint(_Hinge(self, _resolve(parts), a, _unit(b - a, "Die Drehachse (p2 - p1)"), parent, _num(angle, "angle")))++ def slider(self, parts, direction, parent=None, position=0.0):+ """Schubgelenk: Bauteile verschieben sich entlang direction. position ist der Weg am Anfang (mm)."""+ return self._joint(_Slider(self, _resolve(parts), _unit(direction, "Die Richtung"), parent, _num(position, "position")))++ def part(self, parts, parent=None):+ """Frei bewegte Bauteile: to(lage), translate((x, y, z)), rotate(p1, p2, winkel)."""+ return self._joint(_Free(self, _resolve(parts), parent))++ # -- Zeitleiste --++ def _step(self, t0, t1, text):+ self.steps.append(dict(start=round(t0, 4), end=round(t1, 4), text=text))++ def play(self, *actions, run_time=1.0, ease="smooth"):+ """Bewegungen gleichzeitig ablaufen lassen, dann geht die Zeit um run_time (Sekunden) weiter.+ ease: "smooth" (Standard, sanft an und aus), "linear", "in", "out" oder eine Funktion f(s)."""+ rt = _num(run_time, "run_time", 0.0)+ f = _ease(ease)+ if not actions:+ raise ValueError("play() braucht mindestens eine Bewegung, z. B. play(deckel.to(90)). Zum Warten: wait()")+ seen = set()+ t0, t1 = self.time, self.time + rt+ for act in actions:+ if not isinstance(act, _Action):+ raise ValueError(f"play() erwartet Bewegungen wie gelenk.to(90) oder a.camera.orbit(90), nicht {act!r}")+ if id(act.target) in seen:+ raise ValueError("Ein Gelenk (oder die Kamera) kommt zweimal im selben play() vor")+ seen.add(id(act.target))+ 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))+ 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))+ j.value = end+ self.time = t1++ def wait(self, seconds=1.0):+ """Nichts bewegt sich, die Zeit geht weiter."""+ s = _num(seconds, "Die Wartezeit", 0.0)+ self._step(self.time, self.time + s, "Pause")+ self.time += s++ # -- Texte und Hervorhebungen --++ def title(self, text, subtitle=None, duration=2.0):+ """Titelkarte in der Bildmitte. Die Zeit geht um duration weiter (wie wait)."""+ d = _num(duration, "duration", 0.0)+ t = dict(start=self.time, end=self.time + d, text=_text(text, "Der Titel"))+ if subtitle:+ t["subtitle"] = _text(subtitle, "Der Untertitel")+ self.titles.append(t)+ self._step(self.time, self.time + d, f"Titel: {t['text']}")+ self.time += d++ def caption(self, text, duration=None):+ """Untertitel unten im Bild, ab jetzt bis zum naechsten Untertitel (oder duration Sekunden). caption(None) blendet aus."""+ if text is None or text == "":+ self.captions.append(dict(start=self.time, end=None, text=""))+ return+ d = None if duration is None else _num(duration, "duration", 0.0)+ c = dict(start=self.time, end=None if d is None else self.time + d, text=_text(text, "Der Untertitel"))+ self.captions.append(c)+ self._step(self.time, self.time if d is None else self.time + d, f"Untertitel: {c['text']}")++ def label(self, text, part=None, at=None, duration=None):+ """Beschriftung an einer Stelle im Modell, ab jetzt (bis zum Ende oder duration Sekunden). part: Das Schild wandert+ mit diesem Bauteil. at: Punkt (mm, in der Lage im Modell), ohne at die Mitte des Bauteils."""+ if part is None and at is None:+ raise ValueError("label() braucht part= oder at=")+ names = _resolve(part, "part") if part is not None else []+ if len(names) > 1:+ raise ValueError(f"label(part=...) braucht ein einzelnes Bauteil, {part!r} sind {len(names)}")+ d = None if duration is None else _num(duration, "duration", 0.0)+ lb = dict(start=self.time, end=None if d is None else self.time + d, text=_text(text, "Die Beschriftung"),+ part=names[0] if names else None, at=None if at is None else [float(x) for x in _vec(at, "at")])+ self.labels.append(lb)+ self._step(self.time, self.time, f"Beschriftung: {lb['text']}")++ def _event(self, kind, parts, what):+ names = _resolve(parts)+ self.events.append(dict(t=self.time, kind=kind, parts=names))+ self._step(self.time, self.time, f"{what}: {', '.join(names[:4])}{' ...' if len(names) > 4 else ''}")++ def highlight(self, parts, duration=None):+ """Bauteile hervorheben (orange), ab jetzt bis unhighlight() oder duration Sekunden."""+ self._event("highlight", parts, "Hervorheben")+ if duration is not None:+ d = _num(duration, "duration", 0.0)+ self.events.append(dict(t=self.time + d, kind="unhighlight", parts=_resolve(parts)))++ def unhighlight(self, parts):+ self._event("unhighlight", parts, "Hervorhebung aus")++ def hide(self, parts):+ """Bauteile ausblenden (bis show())."""+ self._event("hide", parts, "Ausblenden")++ def show(self, parts):+ self._event("show", parts, "Einblenden")++ def ghost(self, parts, on=True):+ """Bauteile durchsichtig zeigen (on=False: wieder deckend). So sieht man, was dahinter liegt."""+ self._event("ghost" if on else "solid", parts, "Durchsichtig" if on else "Wieder deckend")++ # -- Auswertung (fuer animrun.py) --++ @property+ def duration(self):+ ends = [self.time] + [e["t"] for e in self.events]+ ends += [c["end"] for c in self.captions + self.labels if c["end"] is not None]+ return max(ends)++ def part_joint(self):+ """Bauteilname -> Gelenk."""+ return {p: j for j in self.joints for p in j.parts}++ def moving_parts(self):+ return [p for j in self.joints for p in j.parts]++ def poses(self, t):+ """Lage jedes bewegten Bauteils zur Zeit t (4x4-Matrix)."""+ return {p: j.matrix(t) for j in self.joints for p in j.parts}diff --git a/python/soma/animrun.py b/python/soma/animrun.pynew file mode 100644index 0000000..dd4ece1--- /dev/null+++ b/python/soma/animrun.py@@ -0,0 +1,558 @@+"""`soma anim`: Animationsdateien (animations/*.py) ausfuehren, abtasten und als glTF-Animation schreiben (E58).++Ergebnis je Animation: .soma/anim/<id>.glb mit einem Knoten je bewegtem Bauteil (Name wie in add_part), einer Kamera und+ihrem Zielpunkt, abgetastet mit 30 Bildern je Sekunde. Texte, Hervorhebungen und der Ablauf stehen in den extras.+Dazu .soma/anim/index.json: welche Animationen es gibt, aus welcher Datei, und Fehler je Datei.+"""+import json+import math+import os+import runpy+import sys+import time+from pathlib import Path++import numpy as np++from . import anim, build, gltf, registry++ANIM_DIR = "animations"+OUT_DIR = Path(".soma") / "anim"+++class AnimError(Exception):+ pass+++def _rel(p, root):+ return build._rel(p, root)+++def anim_files(root):+ d = Path(root) / ANIM_DIR+ return sorted(p for p in d.glob("*.py") if p.is_file() and not p.name.startswith("_")) if d.is_dir() else []+++def newest_source(root, extra=()):+ """Neuester Aenderungszeitpunkt des Modells (Einstiegspunkt, *.py im Projektordner, parts/, inputs/) und weiterer Dateien."""+ root = Path(root)+ newest = 0.0+ for top in ("parts", "inputs"):+ for dirpath, dirs, files in os.walk(root / top):+ dirs[:] = [d for d in dirs if d != "__pycache__"]+ for f in files:+ try:+ newest = max(newest, os.path.getmtime(os.path.join(dirpath, f)))+ except OSError:+ pass+ for p in list(root.glob("*.py")) + [Path(x) for x in extra]:+ try:+ newest = max(newest, p.stat().st_mtime)+ except OSError:+ pass+ return newest+++def read_index(root):+ try:+ return json.loads((Path(root) / OUT_DIR / "index.json").read_text(encoding="utf-8"))+ except (OSError, ValueError):+ return dict(version=1, animations=[], errors=[])+++def _parts_info(parts):+ out = []+ for p in parts:+ bb = p["shape"].BoundingBox()+ out.append(dict(name=p["name"], group=tuple(p.get("group", ())), bbox=((bb.xmin, bb.ymin, bb.zmin), (bb.xmax, bb.ymax, bb.zmax))))+ return out+++def _run_file(root, path):+ """Fuehrt eine Animationsdatei aus und gibt ihre Animationen zurueck. Die Datei darf `from model import ...` nutzen:+ add_part() bleibt dabei wirkungslos, die Bauteile kennt soma schon aus dem Build."""+ anim.ANIMATIONS.clear()+ old_cwd = os.getcwd()+ os.chdir(root)+ sys.path.insert(0, str(root))+ registry.IGNORE_ADD = True+ try:+ runpy.run_path(str(path), run_name="__main__")+ except SystemExit as e:+ if e.code not in (None, 0):+ raise build.BuildError(f"{_rel(path, root)} hat sich mit Code {e.code} beendet", file=_rel(path, root), kind="SystemExit")+ except BaseException as e:+ raise build._error_from_exception(e, root)+ finally:+ registry.IGNORE_ADD = False+ os.chdir(old_cwd)+ if sys.path and sys.path[0] == str(root):+ sys.path.pop(0)+ found = list(anim.ANIMATIONS)+ if not found:+ raise build.BuildError(f"{_rel(path, root)} legt keine Animation an. Beginne mit a = Animation(\"Name\") "+ "(from soma.anim import Animation).", file=_rel(path, root), kind="NoAnimation")+ return found+++def load(root, only=None):+ """Modell bauen (nur ausfuehren) und Animationsdateien laufen lassen. Liefert (Bauteile, [(datei, [Animation] | BuildError)])."""+ root = Path(root).resolve()+ parts = build.run_model(root)+ anim._PARTS = _parts_info(parts)+ files = anim_files(root)+ if only is not None:+ files = [f for f in files if f.resolve() == Path(only).resolve()]+ results = []+ for f in files:+ try:+ results.append((f, _run_file(root, f)))+ except build.BuildError as e:+ results.append((f, e))+ return parts, results+++# ---- Abtasten ---------------------------------------------------------------------------------------------------++def sample_times(duration):+ n = max(2, int(math.ceil(duration * anim.SAMPLE_FPS)) + 1)+ return np.linspace(0.0, duration, n)+++def _corners(bbox):+ (x0, y0, z0), (x1, y1, z1) = bbox+ return np.array([[x, y, z, 1.0] for x in (x0, x1) for y in (y0, y1) for z in (z0, z1)])+++def _fit(a, names, times, poses):+ """Mitte und Abstand, damit die Bauteile ueber die ganze Bewegung ins Bild passen (wie viewer.setView)."""+ info = {p["name"]: p for p in anim._PARTS}+ pts = []+ for n in names or info.keys():+ c = _corners(info[n]["bbox"])+ if n in poses[0]:+ for k in range(len(times)):+ pts.append((poses[k][n] @ c.T).T[:, :3])+ else:+ pts.append(c[:, :3])+ pts = np.concatenate(pts)+ lo, hi = pts.min(axis=0), pts.max(axis=0)+ center = (lo + hi) / 2+ radius = max(float(np.linalg.norm(hi - lo)) / 2, 1.0)+ return center, radius / math.sin(math.radians(anim.FOV / 2)) * 1.05+++def _slerp_dir(d0, d1, s):+ d = float(np.clip(np.dot(d0, d1), -1, 1))+ if d > 0.9995:+ v = d0 + (d1 - d0) * s+ return v / np.linalg.norm(v)+ if d < -0.9995: # genau gegenueber: ueber die Hochachse herumschwenken+ perp = np.cross(d0, (0, 0, 1))+ perp = perp / np.linalg.norm(perp) if np.linalg.norm(perp) > 1e-9 else np.array([1.0, 0, 0])+ th = math.pi * s+ return d0 * math.cos(th) + perp * math.sin(th)+ th = math.acos(d)+ return (math.sin((1 - s) * th) * d0 + math.sin(s * th) * d1) / math.sin(th)+++def _rot_z(d, deg):+ a = math.radians(deg)+ c, s = math.cos(a), math.sin(a)+ return np.array([c * d[0] - s * d[1], s * d[0] + c * d[1], d[2]])+++def _tilt(d, deg):+ el = math.asin(max(-1.0, min(1.0, d[2])))+ az = math.atan2(d[1], d[0])+ el = max(-math.radians(89), min(math.radians(89), el + math.radians(deg)))+ return np.array([math.cos(el) * math.cos(az), math.cos(el) * math.sin(az), math.sin(el)])+++def camera_track(a, times, poses):+ """Kamera je Abtastzeit: (Mitte, Richtung zur Kamera, Abstand). auto: Die Animation legt keine Kamera fest."""+ fit_cache = {}++ def fit(names):+ key = tuple(names) if names else None+ if key not in fit_cache:+ fit_cache[key] = _fit(a, names, times, poses)+ return fit_cache[key]++ def resolve(spec, cur):+ target, d, dist = cur+ if "dir" in spec:+ d = np.asarray(spec["dir"], dtype=float)+ if "fit" in spec:+ target, dist = fit(spec["fit"])+ if "target" in spec:+ target = np.asarray(spec["target"], dtype=float)+ if "distance" in spec:+ dist = spec["distance"]+ if "zoom" in spec:+ dist = dist / spec["zoom"]+ return (np.asarray(target, dtype=float), d / np.linalg.norm(d), float(dist))++ t0, dist0 = fit(None)+ start = (t0, np.asarray(anim.VIEWS["iso"], dtype=float) / np.linalg.norm(anim.VIEWS["iso"]), dist0)+ ops = a.camera.ops+ # Jede Bewegung beginnt beim Ende der vorigen+ plan, cur = [], start+ for op in ops:+ if op["kind"] in ("set", "move"):+ end = resolve(op["spec"], cur)+ elif op["kind"] == "orbit":+ d = _tilt(_rot_z(cur[1], op["spec"]["orbit"]), op["spec"]["tilt"])+ end = (cur[0], d, cur[2])+ else:+ end = (cur[0], cur[1], cur[2] / op["spec"]["zoom"])+ plan.append((op, cur, end))+ cur = end++ def at(t):+ state = start+ for op, s0, s1 in plan:+ if t >= op["t1"] and not (op["t0"] == op["t1"] and t < op["t0"]):+ state = s1+ elif op["t0"] <= t < op["t1"]:+ s = op["ease"]((t - op["t0"]) / (op["t1"] - op["t0"]))+ if op["kind"] == "orbit":+ d = _tilt(_rot_z(s0[1], op["spec"]["orbit"] * s), op["spec"]["tilt"] * s)+ return (s0[0], d, s0[2])+ if op["kind"] == "zoom":+ return (s0[0], s0[1], s0[2] / op["spec"]["zoom"] ** s)+ target = s0[0] + (s1[0] - s0[0]) * s+ dist = math.exp(math.log(s0[2]) + (math.log(s1[2]) - math.log(s0[2])) * s)+ return (target, _slerp_dir(s0[1], s1[1], s), dist)+ else:+ break+ return state++ return [at(t) for t in times], not ops+++def _camera_quat(d):+ """Lage einer glTF-Kamera (schaut entlang -Z, oben +Y), die entlang -d blickt, mit Z nach oben."""+ z = d / np.linalg.norm(d)+ x = np.cross((0.0, 0.0, 1.0), z)+ if np.linalg.norm(x) < 1e-9:+ x = np.array([1.0, 0.0, 0.0])+ x = x / np.linalg.norm(x)+ y = np.cross(z, x)+ m = np.eye(4)+ m[:3, 0], m[:3, 1], m[:3, 2] = x, y, z+ return anim._quat(m)+++def _spans(a, duration):+ """Hervorhebungen, ausgeblendete und durchsichtige Bauteile als Zeitspannen je Bauteil."""+ pairs = {"highlight": ("highlight", "unhighlight"), "hidden": ("hide", "show"), "ghost": ("ghost", "solid")}+ out = {}+ for key, (on, off) in pairs.items():+ spans, open_ = {}, {}+ for e in sorted(a.events, key=lambda e: e["t"]):+ for p in e["parts"]:+ if e["kind"] == on and p not in open_:+ open_[p] = e["t"]+ elif e["kind"] == off and p in open_:+ spans.setdefault(p, []).append([round(open_.pop(p), 4), round(e["t"], 4)])+ for p, t in open_.items():+ spans.setdefault(p, []).append([round(t, 4), round(duration, 4)])+ out[key] = spans+ return out+++def finalize(a):+ """Abgetastete Daten einer Animation (fuer die Datei, die Textausgabe und die Pruefung)."""+ duration = a.duration+ if duration <= 0:+ raise build.BuildError(f"Die Animation {a.name!r} ist leer: Sie braucht play(), wait() oder title(), damit Zeit vergeht.",+ file=a.file, line=a.line, kind="EmptyAnimation")+ times = sample_times(duration)+ poses = [a.poses(t) for t in times]+ cams, auto = camera_track(a, times, poses)+ captions = []+ for i, c in enumerate(a.captions):+ nxt = next((x["start"] for x in a.captions[i + 1:] if x["start"] >= c["start"]), duration)+ end = c["end"] if c["end"] is not None else nxt+ if c["text"] and end > c["start"]:+ captions.append(dict(start=round(c["start"], 4), end=round(min(end, duration), 4), text=c["text"]))+ info = {p["name"]: p for p in anim._PARTS}+ labels = []+ for lb in a.labels:+ at = lb["at"]+ if at is None:+ (x0, y0, z0), (x1, y1, z1) = info[lb["part"]]["bbox"]+ at = [(x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2]+ labels.append(dict(start=round(lb["start"], 4), end=round(lb["end"] if lb["end"] is not None else duration, 4),+ text=lb["text"], part=lb["part"], at=[round(v, 4) for v in at]))+ return dict(times=times, poses=poses, cams=cams, auto=auto, duration=duration, captions=captions, labels=labels,+ titles=[dict(t, start=round(t["start"], 4), end=round(t["end"], 4)) for t in a.titles],+ spans=_spans(a, duration))+++def write_glb(root, a, data):+ """.soma/anim/<id>.glb: Knoten je bewegtem Bauteil, Kamera und Ziel, eine Animation, Metadaten in extras."""+ g = gltf.Glb()+ times = data["times"]+ t_acc = g.accessor(times.astype(np.float32), "SCALAR", minmax=True)+ channels, samplers, children = [], [], []++ def channel(node, path, values, kind):+ samplers.append(dict(input=t_acc, output=g.accessor(np.asarray(values, dtype=np.float32), kind), interpolation="LINEAR"))+ channels.append(dict(sampler=len(samplers) - 1, target=dict(node=node, path=path)))++ for name in a.moving_parts():+ ms = [p[name] for p in data["poses"]]+ n = g.node(name=name, extras=dict(soma=dict(part=name)))+ children.append(n)+ channel(n, "translation", [m[:3, 3] for m in ms], "VEC3")+ quats = [anim._quat(m) for m in ms]+ for i in range(1, len(quats)): # auf derselben Halbkugel bleiben, sonst dreht die Interpolation den langen Weg+ if np.dot(quats[i - 1], quats[i]) < 0:+ quats[i] = -quats[i]+ channel(n, "rotation", quats, "VEC4")+ cam = g.node(name="camera", camera=g.camera(math.radians(anim.FOV)), extras=dict(soma=dict(camera=True)))+ tgt = g.node(name="camera-target", extras=dict(soma=dict(cameraTarget=True)))+ children += [cam, tgt]+ channel(cam, "translation", [c[0] + c[1] * c[2] for c in data["cams"]], "VEC3")+ quats = [_camera_quat(c[1]) for c in data["cams"]]+ for i in range(1, len(quats)):+ if np.dot(quats[i - 1], quats[i]) < 0:+ quats[i] = -quats[i]+ channel(cam, "rotation", quats, "VEC4")+ channel(tgt, "translation", [c[0] for c in data["cams"]], "VEC3")+ g.animations.append(dict(name=a.name, channels=channels, samplers=samplers))+ root_node = g.node(name="soma-animation", children=children)+ meta = dict(version=1, id=a.id, name=a.name, file=_rel(a.file, root), line=a.line, duration=round(data["duration"], 4),+ fps=anim.SAMPLE_FPS, fov=anim.FOV, cameraAuto=data["auto"], parts=a.moving_parts(),+ captions=data["captions"], titles=data["titles"], labels=data["labels"], states=data["spans"],+ steps=a.steps, built=time.time())+ out = Path(root) / OUT_DIR+ out.mkdir(parents=True, exist_ok=True)+ path = out / f"{a.id}.glb"+ tmp = path.with_suffix(".glb.part")+ g.write(tmp, [root_node], extras=dict(soma_animation=meta))+ gltf.replace(tmp, path)+ return path+++def build_all(root, only=None):+ """Baut alle Animationen (oder die einer Datei). Liefert dict(built=[...], errors=[...]) und schreibt index.json.+ Ein kaputtes Modell ist ein Fehler fuer alle Animationen."""+ root = Path(root).resolve()+ old = read_index(root)+ try:+ _parts, results = load(root, only)+ except build.BuildError as e:+ raise AnimError(f"Das Modell laesst sich nicht bauen, deshalb auch keine Animation: {e.message}"+ + (f" ({e.file}:{e.line})" if e.file and e.line else "")) from None+ done_files = {_rel(f, root) for f, _ in results}+ keep = [x for x in old.get("animations", []) if x.get("file") not in done_files and (root / x.get("file", "")).is_file()]+ errors = [x for x in old.get("errors", []) if x.get("file") not in done_files and (root / x.get("file", "")).is_file()]+ built, taken = [], {x["id"]: x["file"] for x in keep}+ for f, res in results:+ rel = _rel(f, root)+ if isinstance(res, build.BuildError):+ errors.append(dict(file=res.file or rel, line=res.line, message=res.message, traceback=res.tb))+ continue+ for a in res:+ try:+ if a.id in taken:+ raise build.BuildError(f"Die Animation {a.name!r} gibt es schon (in {taken[a.id]}). Namen muessen eindeutig sein.",+ file=_rel(a.file, root), line=a.line, kind="DuplicateName")+ taken[a.id] = rel+ data = finalize(a)+ path = write_glb(root, a, data)+ built.append(dict(id=a.id, name=a.name, file=rel, line=a.line, duration=round(data["duration"], 4),+ built=time.time(), glb=path.relative_to(root).as_posix(), parts=len(a.moving_parts())))+ except build.BuildError as e:+ errors.append(dict(file=e.file or rel, line=e.line, message=e.message, traceback=e.tb))+ except Exception as e: # Fehler beim Abtasten, etwa unbrauchbare Werte+ err = build._error_from_exception(e, root)+ errors.append(dict(file=err.file or rel, line=err.line, message=err.message, traceback=err.tb))+ # Dateien von Animationen, die es nicht mehr gibt (umbenannt oder geloescht), sind Zwischenstaende der App+ keep_ids = {x["id"] for x in keep} | {x["id"] for x in built}+ for x in old.get("animations", []):+ if x["id"] not in keep_ids:+ for suffix in (".glb", ".check.json"):+ try:+ (root / OUT_DIR / f"{x['id']}{suffix}").unlink()+ except OSError:+ pass+ index = dict(version=1, animations=sorted(keep + built, key=lambda x: (x["file"], x["line"] or 0)), errors=errors)+ (root / OUT_DIR).mkdir(parents=True, exist_ok=True)+ (root / OUT_DIR / "index.json").write_text(json.dumps(index, indent=1, ensure_ascii=False), encoding="utf-8")+ return dict(built=built, errors=errors, index=index)+++def find(root, name):+ """Eintrag einer Animation im Index: nach Name, Kennung oder Datei."""+ idx = read_index(root)+ for x in idx.get("animations", []):+ if name in (x["name"], x["id"]) or Path(name).as_posix() == x["file"]:+ return x+ return None+++def is_stale(root, entry):+ try:+ built = (Path(root) / entry["glb"]).stat().st_mtime+ except OSError:+ return True+ return newest_source(root, [Path(root) / entry["file"]]) > built+++def ensure(root, name):+ """Animation fertig gebaut und aktuell? Sonst bauen. Liefert den Index-Eintrag oder wirft AnimError mit Erklaerung."""+ root = Path(root).resolve()+ e = find(root, name)+ if e is not None and not is_stale(root, e):+ return e+ # Veraltet: nur die eigene Datei neu bauen. Unbekannt: alle (vielleicht ist die Datei neu)+ res = build_all(root, root / e["file"] if e else None)+ e = find(root, name)+ if e is None: # Eine Datei mit Fehler verliert ihre Eintraege, die Meldung nennt den Fehler+ names = [x["name"] for x in res["index"]["animations"]]+ msg = f"Keine Animation {name!r}."+ if res["errors"]:+ msg += " Fehler: " + "; ".join(f"{x['file']}{':' + str(x['line']) if x.get('line') else ''}: {x['message']}" for x in res["errors"])+ msg += f" Vorhanden: {', '.join(repr(n) for n in names)}." if names else f" In {ANIM_DIR}/ liegt noch keine fehlerfreie Animation."+ raise AnimError(msg)+ return e+++def read_meta(root, entry):+ return gltf.read_json(Path(root) / entry["glb"])["extras"]["soma_animation"]+++# ---- Text fuer den Agenten --------------------------------------------------------------------------------------++def _t(x):+ return f"{x:.2f}"+++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"]:+ 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"]:+ lines += ["", "Untertitel:"] + [f" {_t(c['start'])}-{_t(c['end'])} s \"{c['text']}\"" for c in m["captions"]]+ if m["labels"]:+ lines += ["", "Beschriftungen:"] + [+ f" {_t(lb['start'])}-{_t(lb['end'])} s \"{lb['text']}\"" + (f" an {lb['part']}" if lb["part"] else "")+ + " bei ({:.1f}, {:.1f}, {:.1f})".format(*lb["at"]) for lb in m["labels"]]+ chk = read_check(root, entry)+ if chk:+ lines += ["", check_text(chk)]+ else:+ lines += ["", "Kollisionen: nicht geprueft (soma anim check \"" + m["name"] + "\")"]+ return "\n".join(lines)+++# ---- Kollisionspruefung -----------------------------------------------------------------------------------------++def _location(m):+ import cadquery as cq+ from OCP.gp import gp_Trsf+ t = gp_Trsf()+ t.SetValues(*[float(m[r, c]) for r in range(3) for c in range(4)])+ return cq.Location(t)+++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+ 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}+ duration = a.duration+ times = set(np.round(np.arange(0.0, duration + 1e-9, max(step, 0.01)), 4).tolist())+ for s in a.steps:+ 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()+ 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):+ continue+ pairs.append((m, o))+ corners = {n: _corners(info[n]["bbox"]) for n in shapes}+ eye = np.eye(4)+ 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)))+ 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:+ cur["end"] = h["t"]+ cur["volume"] = max(cur["volume"], h["volume"])+ cur["distance"] = min(cur["distance"], h["distance"])+ else:+ cur = dict(kind=kind, start=h["t"], end=h["t"], volume=h["volume"], distance=h["distance"])+ 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)+ (root / OUT_DIR / f"{entry['id']}.check.json").write_text(json.dumps(res, indent=1, ensure_ascii=False), encoding="utf-8")+ return res+++def read_check(root, entry):+ p = Path(root) / OUT_DIR / f"{entry['id']}.check.json"+ try:+ if p.stat().st_mtime < (Path(root) / entry["glb"]).stat().st_mtime:+ return None # gehoert zu einem aelteren Stand der Animation+ return json.loads(p.read_text(encoding="utf-8"))+ except (OSError, ValueError):+ return None+++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]+ for p in res["pairs"]:+ note = " (schon 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"+ lines.append(f" {span:<16} {p['a']} / {p['b']}: {r['kind']}, {val}{note}")+ return "\n".join(lines)diff --git a/python/soma/cli.py b/python/soma/cli.pyindex 4e5a2f8..18eccd2 100644--- a/python/soma/cli.py+++ b/python/soma/cli.py@@ -1,4 +1,4 @@-"""Kommandozeile: `soma build` und `soma export`."""+"""Kommandozeile: `soma build`, `soma export`, `soma anim`, `soma analyze` und `soma render`."""import argparseimport jsonimport os@@ -132,6 +132,116 @@ def cmd_serve(args):return 0+def _fail(msg, code=1):+ print(msg, file=sys.stderr)+ return code+++def cmd_anim(args):+ """Animationen in animations/*.py (E58): bauen, auflisten, beschreiben, auf Kollisionen pruefen."""+ from . import animrun+ root = Path(args.project).resolve()+ try:+ if args.action == "build":+ target = None+ if args.name and args.name.endswith(".py"):+ target = root / args.name+ if not target.is_file():+ return _fail(f"{args.name} gibt es nicht")+ res = animrun.build_all(root, target)+ if args.json:+ print(json.dumps(dict(built=res["built"], errors=res["errors"]), ensure_ascii=False))+ else:+ for b in res["built"]:+ print(f"Animation ok: \"{b['name']}\" ({b['duration']:.2f} s, {b['parts']} bewegte(s) Bauteil(e)) aus {b['file']}")+ for e in res["errors"]:+ where = f"{e['file']}{':' + str(e['line']) if e.get('line') else ''}"+ print(f"Animation FEHLER ({where}): {e['message']}", file=sys.stderr)+ if e.get("traceback"):+ print(e["traceback"], file=sys.stderr)+ if not res["built"] and not res["errors"]:+ print(f"Keine Animationen: Lege eine Datei in {animrun.ANIM_DIR}/ an (from soma.anim import Animation).")+ if args.name and not args.name.endswith(".py") and not animrun.find(root, args.name):+ return _fail(f"Keine Animation {args.name!r} gefunden")+ return 1 if res["errors"] else 0+ if args.action == "list":+ idx = animrun.read_index(root)+ rows = [dict(x, stale=animrun.is_stale(root, x)) for x in idx.get("animations", [])]+ if args.json:+ print(json.dumps(dict(animations=rows, errors=idx.get("errors", [])), ensure_ascii=False))+ return 0+ for x in rows:+ print(f"\"{x['name']}\" {x['duration']:.2f} s {x['file']}{' (veraltet, soma anim build)' if x['stale'] else ''}")+ for e in idx.get("errors", []):+ print(f"FEHLER {e['file']}{':' + str(e['line']) if e.get('line') else ''}: {e['message']}")+ if not rows and not idx.get("errors"):+ print("Noch keine Animation gebaut (soma anim build).")+ return 0+ if not args.name:+ return _fail(f"soma anim {args.action} braucht den Namen der Animation")+ entry = animrun.ensure(root, args.name)+ if args.action == "info":+ if args.json:+ print(json.dumps(dict(meta=animrun.read_meta(root, entry), check=animrun.read_check(root, entry)), ensure_ascii=False))+ else:+ print(animrun.info_text(root, entry))+ return 0+ res = animrun.check(root, args.name, step=args.step, gap=args.gap)+ print(json.dumps(res, ensure_ascii=False) if args.json else animrun.check_text(res))+ return 1 if any(r["kind"] == "Kollision" and not p["atRest"] for p in res["pairs"] for r in p["ranges"]) else 0+ except animrun.AnimError as e:+ return _fail(str(e))+++def cmd_analyze(args):+ """Auswertung mit einem Wert je Stelle der Oberflaeche (E58)."""+ from . import analysis+ root = Path(args.project).resolve()+ if args.kind == "list":+ res = analysis.list_results(root)+ if args.json:+ print(json.dumps(res, ensure_ascii=False))+ return 0+ for m in res:+ print(f"{m['id']}: {m['title']} ({m['file']})")+ if not res:+ print("Noch keine Ergebnisse (soma analyze overhang | thickness | clearance).")+ return 0+ try:+ meta = analysis.run(root, args.kind, args.parts, args.threshold, args.up, args.name)+ except analysis.AnalysisError as e:+ return _fail(str(e))+ if args.json:+ print(json.dumps(meta, ensure_ascii=False))+ else:+ print(meta["summary"])+ print(f"Ergebnis: {meta['file']}. Als Bild mit Farben: soma render --result {meta['id']}")+ return 0+++def cmd_render(args):+ """Bild oder Video ueber die App (E58)."""+ from . import render+ root = Path(args.project).resolve()+ try:+ job = render.prepare(root, args)+ res = render.send(job)+ except render.RenderError as e:+ return _fail(f"Render FEHLER: {e}")+ if args.json:+ print(json.dumps(res, ensure_ascii=False))+ return 0+ for w in res.get("warnings", []):+ print("Hinweis:", w)+ for f in res.get("files", []):+ print(f"geschrieben: {f}")+ if job["kind"] == "video":+ print("Das Video selbst kannst du nicht ansehen, die Uebersicht (PNG) zeigt Standbilder mit Zeitstempel.")+ else:+ print("Oeffne das Bild, um es anzusehen.")+ return 0++def main(argv=None):ap = argparse.ArgumentParser(prog="soma", description="Hilfsprogramm von SOMA")ap.add_argument("--version", action="version", version=f"soma {__version__}")@@ -158,6 +268,39 @@ def main(argv=None):g.add_argument("--json", action="store_true")g.set_defaults(func=cmd_glb)+ a = sub.add_parser("anim", help="Animationen aus animations/*.py bauen, auflisten, beschreiben, pruefen")+ a.add_argument("action", choices=["build", "list", "info", "check"])+ a.add_argument("name", nargs="?", help="Name der Animation (bei build auch eine Datei animations/x.py)")+ a.add_argument("--step", type=float, default=0.1, help="check: Abstand der Zeitpunkte in Sekunden (Standard 0.1)")+ a.add_argument("--gap", type=float, default=0.0, help="check: Mindestabstand in mm, darunter gilt es als zu nah")+ a.add_argument("--project", default=".")+ a.add_argument("--json", action="store_true")+ a.set_defaults(func=cmd_anim)++ 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("--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)")+ z.add_argument("--project", default=".")+ z.add_argument("--json", action="store_true")+ z.set_defaults(func=cmd_analyze)++ r = sub.add_parser("render", help="Bild oder Video des Modells (ueber die App), nach renders/")+ r.add_argument("--view", help="iso, front, back, left, right, top, bottom (Standard iso, bei Animationen ihre Kamera)")+ r.add_argument("--size", help="Breite x Hoehe in Pixeln, z. B. 1280x800")+ r.add_argument("--anim", help="Name einer Animation")+ r.add_argument("--at", type=float, help="Zeitpunkt in der Animation (Sekunden)")+ r.add_argument("--sheet", nargs="?", const=True, help="Uebersicht: Standbilder der Animation mit Zeit, z. B. 3x3")+ r.add_argument("--video", action="store_true", help="Video (MP4) der Animation")+ r.add_argument("--fps", type=int, default=30, help="Bilder je Sekunde im Video")+ r.add_argument("--result", help="Ergebnis einer Auswertung (soma analyze) farbig zeigen")+ r.add_argument("--out", help="Zieldatei im Projekt (Standard: renders/...)")+ r.add_argument("--project", default=".")+ r.add_argument("--json", action="store_true")+ r.set_defaults(func=cmd_render)+s = sub.add_parser("serve", help="Messdienst fuer die App (JSON-Zeilen auf stdin/stdout)")s.set_defaults(func=cmd_serve)diff --git a/python/soma/gltf.py b/python/soma/gltf.pynew file mode 100644index 0000000..a1ad789--- /dev/null+++ b/python/soma/gltf.py@@ -0,0 +1,115 @@+"""Kleiner GLB-Schreiber (glTF 2.0, binaer) fuer Animationen und Analyse-Ergebnisse (E58).++Das Modell selbst schreibt mesher.write_glb. Hier geht es um Dateien, die andere Programme ebenfalls lesen sollen:+Animationen (Knoten mit Bewegung, Kamera) und Ergebnisse (Netze mit einem Wert je Eckpunkt). Einheit mm, Z oben.+"""+import json+import struct++import numpy as np++FLOAT, UINT = 5126, 5125+ARRAY_BUFFER, ELEMENT_ARRAY_BUFFER = 34962, 34963+_COMPONENTS = {"SCALAR": 1, "VEC2": 2, "VEC3": 3, "VEC4": 4}+++class Glb:+ """Sammelt Puffer, Zugriffe, Knoten, Netze, Kameras und Animationen und schreibt sie als eine GLB-Datei."""++ def __init__(self):+ self.blob = bytearray()+ self.views, self.accessors, self.materials, self.meshes = [], [], [], []+ self.nodes, self.cameras, self.animations = [], [], []++ def accessor(self, arr, kind, target=None, minmax=False):+ """Legt ein Feld ab und gibt die Nummer des Zugriffs zurueck. Indizes (target ELEMENT_ARRAY_BUFFER) als uint32,+ alles andere als float32."""+ arr = np.ascontiguousarray(arr, dtype=np.uint32 if target == ELEMENT_ARRAY_BUFFER else np.float32)+ while len(self.blob) % 4:+ self.blob.append(0)+ view = dict(buffer=0, byteOffset=len(self.blob), byteLength=arr.nbytes)+ if target:+ view["target"] = target+ self.views.append(view)+ self.blob.extend(arr.tobytes())+ n = _COMPONENTS[kind]+ acc = dict(bufferView=len(self.views) - 1, componentType=UINT if arr.dtype == np.uint32 else FLOAT,+ count=int(arr.size // n), type=kind)+ if minmax and arr.size:+ flat = arr.reshape(-1, n)+ acc["min"] = [float(x) for x in flat.min(axis=0)]+ acc["max"] = [float(x) for x in flat.max(axis=0)]+ self.accessors.append(acc)+ return len(self.accessors) - 1++ def material(self, **m):+ self.materials.append(m)+ return len(self.materials) - 1++ def mesh(self, name, primitives):+ self.meshes.append(dict(name=name, primitives=primitives))+ return len(self.meshes) - 1++ def node(self, **n):+ self.nodes.append(n)+ return len(self.nodes) - 1++ def camera(self, yfov, znear=0.5, zfar=20000.0, aspect=None):+ cam = dict(yfov=float(yfov), znear=float(znear), zfar=float(zfar))+ if aspect:+ cam["aspectRatio"] = float(aspect)+ self.cameras.append(dict(type="perspective", perspective=cam))+ return len(self.cameras) - 1++ def write(self, path, roots, extras=None, scene_extras=None):+ gltf = dict(asset=dict(version="2.0", generator="soma"), scene=0, scenes=[dict(nodes=list(roots))], nodes=self.nodes)+ if scene_extras:+ gltf["scenes"][0]["extras"] = scene_extras+ for key in ("meshes", "materials", "cameras", "animations", "accessors"):+ if getattr(self, key):+ gltf[key] = getattr(self, key)+ if self.views:+ gltf["bufferViews"] = self.views+ gltf["buffers"] = [dict(byteLength=len(self.blob))]+ if extras:+ gltf["extras"] = extras+ js = json.dumps(gltf, separators=(",", ":"), ensure_ascii=False).encode("utf-8")+ js += b" " * (-len(js) % 4)+ while len(self.blob) % 4:+ self.blob.append(0)+ total = 12 + 8 + len(js) + (8 + len(self.blob) if self.blob else 0)+ with open(path, "wb") as f:+ f.write(struct.pack("<III", 0x46546C67, 2, total))+ f.write(struct.pack("<II", len(js), 0x4E4F534A))+ f.write(js)+ if self.blob:+ f.write(struct.pack("<II", len(self.blob), 0x004E4942))+ f.write(self.blob)+ return total+++def replace(tmp, path, tries=20):+ """Fertige Datei an ihren Platz. Unter Windows schlaegt das fehl, solange ein anderer Prozess die alte gerade liest+ (App und Agent bauen gleichzeitig): kurz warten und noch einmal."""+ import os+ import time+ for i in range(tries):+ try:+ os.replace(tmp, path)+ return+ except PermissionError:+ if i == tries - 1:+ raise+ time.sleep(0.1)+++def read_json(path):+ """Nur den JSON-Teil einer GLB-Datei lesen (Metadaten in extras), ohne die Binaerdaten."""+ with open(path, "rb") as f:+ magic, _version, _total = struct.unpack("<III", f.read(12))+ if magic != 0x46546C67:+ raise ValueError(f"{path} ist keine GLB-Datei")+ length, kind = struct.unpack("<II", f.read(8))+ if kind != 0x4E4F534A:+ raise ValueError(f"{path}: JSON-Teil fehlt")+ return json.loads(f.read(length).decode("utf-8"))diff --git a/python/soma/registry.py b/python/soma/registry.pyindex 82db842..eb3aad2 100644--- a/python/soma/registry.py+++ b/python/soma/registry.py@@ -6,6 +6,9 @@ import unicodedataimport cadquery as cqREGISTRY = [] # wird pro Build geleert (siehe build.py)+# Beim Ausfuehren von Animationsdateien (animrun.py): Die Bauteile sind schon bekannt. Importiert eine Animation das Modell+# (`from model import HINGE_Y`), laeuft model.py ein zweites Mal, add_part() bleibt dann wirkungslos.+IGNORE_ADD = FalseDEFAULT_COLORS = {"part": (0.62, 0.66, 0.72), "reference": (0.1, 0.65, 0.3), "hardware": (0.45, 0.46, 0.49)}REFERENCE_ALPHA = 0.45ROLES = ("part", "reference", "hardware")@@ -76,6 +79,8 @@ def add_part(name, obj, role=None, color=None, group=None):color optional (r, g, b) mit Werten 0..1 (bei einer Baugruppe fuer alle Teile). Normteile haben eine eigenegroup optional, Gruppe im Bauteilbaum und in der STEP-Datei, verschachtelt mit "/", z. B. "Gehaeuse/Schrauben""""+ if IGNORE_ADD:+ returnstandard_part = hasattr(obj, "__soma_shape__")if role is None:role = getattr(obj, "role", "part") if standard_part else "part"diff --git a/python/soma/render.py b/python/soma/render.pynew file mode 100644index 0000000..ad39003--- /dev/null+++ b/python/soma/render.py@@ -0,0 +1,137 @@+"""`soma render`: Bilder und Videos des Modells, gerendert von der App (E58).++Die App zeichnet mit demselben Viewer wie auf dem Bildschirm, in einem unsichtbaren Fenster. Dieser Befehl bereitet den+Auftrag vor (Animation bauen, Ergebnis suchen) und schickt ihn ueber eine lokale Verbindung an die App. Die Adresse und+ein Schluessel stehen in den Umgebungsvariablen der Terminals der App (SOMA_APP, SOMA_APP_TOKEN).+"""+import http.client+import json+import os+import re+from pathlib import Path++from . import analysis, animrun++VIEWS = ("iso", "front", "back", "left", "right", "top", "bottom")+MAX_SIDE = 3840+++class RenderError(Exception):+ pass+++def _size(text, default):+ if not text:+ return default+ m = re.fullmatch(r"\s*(\d{2,5})\s*[xX*]\s*(\d{2,5})\s*", text)+ if not m:+ raise RenderError(f"--size {text!r}: erwartet Breite x Hoehe, z. B. 1280x720")+ w, h = int(m.group(1)), int(m.group(2))+ if not (64 <= w <= MAX_SIDE and 64 <= h <= MAX_SIDE):+ raise RenderError(f"--size {text!r}: Breite und Hoehe zwischen 64 und {MAX_SIDE} Pixeln")+ return w, h+++def _grid(text):+ if text in (None, True, ""):+ return 3, 3+ m = re.fullmatch(r"\s*(\d)\s*[xX]\s*(\d)\s*", str(text))+ if not m or not (1 <= int(m.group(1)) <= 6 and 1 <= int(m.group(2)) <= 6):+ raise RenderError(f"--sheet {text!r}: erwartet Spalten x Zeilen, z. B. 3x3 (hoechstens 6x6)")+ return int(m.group(1)), int(m.group(2))+++def _out(root, out, default, ext):+ rel = Path(out) if out else Path(default)+ if rel.is_absolute():+ try:+ rel = rel.resolve().relative_to(root)+ except ValueError:+ raise RenderError(f"--out {out!r} liegt nicht im Projektordner") from None+ p = rel.as_posix()+ if ".." in rel.parts or p.startswith((".git/", ".soma/")):+ raise RenderError(f"--out {out!r}: Ziel muss im Projektordner liegen, nicht in .git/ oder .soma/")+ if rel.suffix.lower() != ext:+ raise RenderError(f"--out {out!r}: Die Datei muss auf {ext} enden")+ return p+++def _num(t):+ return f"{t:.2f}".rstrip("0").rstrip(".") if t else "0"+++def prepare(root, args):+ """Auftrag fuer die App aus den Argumenten. Baut eine veraltete Animation vorher neu."""+ root = Path(root).resolve()+ job = dict(project=str(root), view=args.view or None, warnings=[])+ if args.view and args.view not in VIEWS:+ raise RenderError(f"--view {args.view!r} gibt es nicht. Moeglich: {', '.join(VIEWS)}")+ modes = [x for x in ("at", "sheet", "video") if getattr(args, x) not in (None, False)]+ if modes and not args.anim:+ raise RenderError(f"--{modes[0]} gehoert zu einer Animation: --anim \"Name\"")+ if len(modes) > 1:+ raise RenderError("Nur eins von --at, --sheet und --video")+ if args.anim and args.result:+ raise RenderError("--anim und --result gehen nicht zusammen")+ if args.result:+ meta = analysis.find(root, args.result)+ if not meta:+ have = [m["id"] for m in analysis.list_results(root)]+ raise RenderError(f"Kein Ergebnis {args.result!r}. " + (f"Vorhanden: {', '.join(have)}" if have else "Erst auswerten, z. B. soma analyze overhang"))+ if animrun.newest_source(root) > meta["created"]:+ job["warnings"].append(f"Das Ergebnis {meta['id']!r} ist aelter als der Code. Neu berechnen: soma {' '.join(meta['command'])}")+ job["result"] = meta["file"]+ if args.anim:+ try:+ entry = animrun.ensure(root, args.anim)+ except animrun.AnimError as e:+ raise RenderError(str(e)) from None+ job["anim"] = entry["glb"]+ dur = entry["duration"]+ if args.video:+ job["kind"] = "video"+ job["size"] = _size(args.size, (1280, 720))+ job["fps"] = args.fps+ if not 1 <= args.fps <= 60:+ raise RenderError("--fps zwischen 1 und 60")+ job["out"] = _out(root, args.out, f"renders/{entry['id']}.mp4", ".mp4")+ elif args.sheet not in (None, False):+ job["kind"] = "sheet"+ job["grid"] = _grid(args.sheet)+ job["size"] = _size(args.size, (480, 300)) # Groesse eines Einzelbilds+ job["out"] = _out(root, args.out, f"renders/{entry['id']}-uebersicht.png", ".png")+ else:+ t = 0.0 if args.at is None else float(args.at)+ if not 0 <= t <= dur + 1e-6:+ raise RenderError(f"--at {t:g}: Die Animation dauert {dur:g} s")+ job["kind"] = "still"+ job["at"] = t+ job["size"] = _size(args.size, (1280, 800))+ job["out"] = _out(root, args.out, f"renders/{entry['id']}-{_num(t)}s.png", ".png")+ else:+ job["kind"] = "still"+ job["size"] = _size(args.size, (1280, 800))+ name = f"ergebnis-{Path(job['result']).stem}" if args.result else f"ansicht-{args.view or 'iso'}"+ job["out"] = _out(root, args.out, f"renders/{name}.png", ".png")+ return job+++def send(job, timeout=900):+ """Schickt den Auftrag an die App und wartet auf das Ergebnis."""+ addr, token = os.environ.get("SOMA_APP"), os.environ.get("SOMA_APP_TOKEN")+ if not addr or not token:+ raise RenderError("soma render braucht die laufende App: Fuehre den Befehl im Terminal der App aus "+ "(dort sind SOMA_APP und SOMA_APP_TOKEN gesetzt).")+ host, _, port = addr.rpartition(":")+ try:+ conn = http.client.HTTPConnection(host or "127.0.0.1", int(port), timeout=timeout)+ conn.request("POST", "/v1/render", json.dumps(job).encode("utf-8"),+ {"Content-Type": "application/json", "X-Soma-Token": token})+ resp = conn.getresponse()+ data = json.loads(resp.read().decode("utf-8") or "{}")+ except (OSError, ValueError) as e:+ raise RenderError(f"Die App antwortet nicht ({addr}): {e}. Laeuft sie noch? Neue Terminals bekommen die neue Adresse.") from None+ if not data.get("ok"):+ raise RenderError(data.get("error") or f"Die App meldet einen Fehler (HTTP {resp.status})")+ data["warnings"] = job.get("warnings", []) + data.get("warnings", [])+ return data