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: Animationen, Auswertungen und Bilder über die App (E58)

Kai-Jungsthoefel688298fd35a1
diff --git a/python/soma/__init__.py b/python/soma/__init__.py
index 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 Modell
diff --git a/python/soma/analysis.py b/python/soma/analysis.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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 argparse
import json
import 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.py
new file mode 100644
index 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.py
index 82db842..eb3aad2 100644
--- a/python/soma/registry.py
+++ b/python/soma/registry.py
@@ -6,6 +6,9 @@ import unicodedata
import cadquery as cq
REGISTRY = [] # 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 = False
DEFAULT_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.45
ROLES = ("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 eigene
group optional, Gruppe im Bauteilbaum und in der STEP-Datei, verschachtelt mit "/", z. B. "Gehaeuse/Schrauben"
"""
+ if IGNORE_ADD:
+ return
standard_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.py
new file mode 100644
index 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