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

13.9 KB
Raw Blame
"""Exaktes Messen fuer den Viewer (E9): Flaechen, Kanten und Eckpunkte ueber die IDs des Meshers, Abstaende und Winkel mit OCC.

Grundlage ist `geometry/<build>.brep` neben model.map.json, aus demselben Build wie model.glb. BREP erhaelt die
Topologie exakt, daher stimmt die Reihenfolge von Faces()/Edges() mit den IDs des Meshers ueberein. Die Kennung im
Dateinamen und in model.map.json verbindet beides, zusaetzlich prueft jede Anfrage Flaecheninhalt bzw. Kantenlaenge.

`soma serve` beantwortet Anfragen als JSON-Zeilen auf stdin/stdout (langlebiger Dienst der App, E24).
"""
import json
import math
import sys
from pathlib import Path

import cadquery as cq
from OCP.BRepAdaptor import BRepAdaptor_Curve, BRepAdaptor_Surface
from OCP.BRepBuilderAPI import BRepBuilderAPI_MakeVertex
from OCP.BRepExtrema import BRepExtrema_DistShapeShape
from OCP.GeomAbs import GeomAbs_Circle, GeomAbs_Cone, GeomAbs_Cylinder, GeomAbs_Line, GeomAbs_Plane, GeomAbs_Sphere, GeomAbs_Torus
from OCP.gp import gp_Pnt
from OCP.TopAbs import TopAbs_REVERSED
from OCP.TopoDS import TopoDS_Iterator

PARALLEL = 1e-6  # Winkeltoleranz (rad) fuer "parallel"


class MeasureError(Exception):
    """Fehler mit verstaendlicher Meldung. `stale`: die Anfrage gehoert zu einem aelteren Build. `rebuilt`: auf der Platte
    liegt ein neuerer Build als im Viewer (etwa `soma build` im Terminal), die App muss ihn erst laden."""

    def __init__(self, message, stale=False, rebuilt=False):
        super().__init__(message)
        self.stale = stale or rebuilt
        self.rebuilt = rebuilt


def write_geometry(folder, shapes, build_id):
    """Legt die Bauteile als ein BREP ab (Reihenfolge = Reihenfolge in model.map.json). Alte Staende raeumt erst
    remove_old_geometry weg, nachdem model.map.json auf den neuen zeigt: Bis dahin misst der Dienst noch den alten."""
    geo = Path(folder) / "geometry"
    geo.mkdir(parents=True, exist_ok=True)
    cq.Compound.makeCompound(list(shapes)).exportBrep(str(geo / f"{build_id}.brep"))


def remove_old_geometry(folder, build_id):
    """Alles ausser dem Stand `build_id` aus geometry/ entfernen, auch Zwischendateien abgebrochener Builds."""
    for old in (Path(folder) / "geometry").glob("*"):
        if old.suffix in (".brep", ".tmp") and not old.name.startswith(build_id):
            try:
                old.unlink()
            except OSError:
                pass  # gerade in Benutzung (Messdienst): beim naechsten Build


class Model:
    """Ein gebauter Stand: Bauteile aus dem BREP, Zuordnung ueber model.map.json."""

    def __init__(self, folder):
        folder = Path(folder)
        try:
            self.map = json.loads((folder / "model.map.json").read_text(encoding="utf-8"))
        except (OSError, ValueError) as e:
            raise MeasureError(f"model.map.json is missing or unreadable: {e}")
        self.build = self.map.get("build")
        brep = folder / "geometry" / f"{self.build}.brep"
        if not self.build or not brep.is_file():
            raise MeasureError("There is no geometry to measure for this version. Building it once more helps.")
        comp = cq.Shape.importBrep(str(brep))
        it = TopoDS_Iterator(comp.wrapped)
        self.shapes = []
        while it.More():
            self.shapes.append(cq.Shape.cast(it.Value()))
            it.Next()
        self.parts = {p["id"]: i for i, p in enumerate(self.map.get("parts", []))}
        self.names = {p["id"]: p.get("name", p["id"]) for p in self.map.get("parts", [])}
        if len(self.shapes) != len(self.parts):
            raise MeasureError("Geometry and part list do not match. Building it once more helps.")
        self._cache = {"face": {}, "edge": {}, "vertex": {}}

    def shape(self, part):
        if part not in self.parts:
            raise MeasureError(f"Unknown part {part!r}.", stale=True)
        return self.shapes[self.parts[part]]

    def sub(self, ent):
        """Flaeche, Kante oder Eckpunkt eines Bauteils. Prueft Flaecheninhalt, Laenge bzw. Lage gegen den Viewer."""
        part, kind, i = ent["part"], ent["kind"], int(ent["id"])
        if kind not in self._cache:
            raise MeasureError(f"Unknown kind {kind!r}.")
        cache = self._cache[kind]
        if part not in cache:
            s = self.shape(part)
            cache[part] = s.Faces() if kind == "face" else s.Edges() if kind == "edge" else s.Vertices()
        items = cache[part]
        if not 0 <= i < len(items):
            raise MeasureError("This spot no longer exists in the current version.", stale=True)
        sub = items[i]
        stale = MeasureError("The geometry does not match the version shown. Please click again.", stale=True)
        if kind == "vertex":
            pt = ent.get("point")
            if pt is not None and math.dist(sub.toTuple(), [float(x) for x in pt]) > 1e-3:
                raise stale
            return sub
        check = ent.get("check")
        if check is not None:
            actual = sub.Area() if kind == "face" else sub.Length()
            if abs(actual - float(check)) > max(1e-3, 1e-3 * abs(actual)):
                raise stale
        return sub


def _xyz(p):
    return [round(p.X(), 6), round(p.Y(), 6), round(p.Z(), 6)]


def _vec(d):
    return [round(d.X(), 9), round(d.Y(), 9), round(d.Z(), 9)]


def _dot(a, b):
    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]


def _sub(a, b):
    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]]


def _norm(a):
    return math.sqrt(_dot(a, a))


def _cross(a, b):
    return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]


def _angle(u, v):
    """Winkel zwischen zwei Richtungen in rad (0..pi)."""
    c = _dot(u, v) / max(_norm(u) * _norm(v), 1e-300)
    return math.acos(max(-1.0, min(1.0, c)))


def _dist(a, b):
    """Kuerzester Abstand zweier Formen mit den beiden naechsten Punkten."""
    d = BRepExtrema_DistShapeShape(a, b)
    if not d.IsDone() or d.NbSolution() < 1:
        raise MeasureError("The distance could not be determined.")
    return d.Value(), _xyz(d.PointOnShape1(1)), _xyz(d.PointOnShape2(1))


def _project(sub, point):
    """Naechster Punkt auf der Flaeche/Kante zum angeklickten Punkt (der Klick liegt auf dem Netz, nicht exakt darauf)."""
    if point is None:
        return None
    v = BRepBuilderAPI_MakeVertex(gp_Pnt(*[float(x) for x in point])).Vertex()
    return _dist(v, sub.wrapped)[2]


def describe(model, ent):
    """Exakte Angaben zu einer Flaeche, Kante oder einem Eckpunkt."""
    sub = model.sub(ent)
    info = dict(kind=ent["kind"], part=ent["part"], name=model.names.get(ent["part"]), point=_project(sub, ent.get("point")))
    if ent["kind"] == "vertex":
        info.update(type="VERTEX", point=[round(c, 6) for c in sub.toTuple()])
    elif ent["kind"] == "face":
        info.update(type=sub.geomType(), area=sub.Area())
        ad = BRepAdaptor_Surface(sub.wrapped)
        t = ad.GetType()
        rev = sub.wrapped.Orientation() == TopAbs_REVERSED
        if t == GeomAbs_Plane:
            pln = ad.Plane()
            n = _vec(pln.Axis().Direction())
            info.update(normal=[-x for x in n] if rev else n, origin=_xyz(pln.Location()))
        elif t == GeomAbs_Cylinder:
            c = ad.Cylinder()
            info.update(radius=c.Radius(), axis=dict(point=_xyz(c.Location()), dir=_vec(c.Axis().Direction())))
        elif t == GeomAbs_Cone:
            c = ad.Cone()
            info.update(semiAngle=math.degrees(c.SemiAngle()), refRadius=c.RefRadius(),
                        axis=dict(point=_xyz(c.Location()), dir=_vec(c.Axis().Direction())))
        elif t == GeomAbs_Sphere:
            s = ad.Sphere()
            info.update(radius=s.Radius(), center=_xyz(s.Location()))
        elif t == GeomAbs_Torus:
            s = ad.Torus()
            info.update(majorRadius=s.MajorRadius(), minorRadius=s.MinorRadius(),
                        axis=dict(point=_xyz(s.Location()), dir=_vec(s.Axis().Direction())))
    else:
        info.update(type=sub.geomType(), length=sub.Length(), start=_xyz(sub.startPoint().toPnt()), end=_xyz(sub.endPoint().toPnt()))
        ad = BRepAdaptor_Curve(sub.wrapped)
        t = ad.GetType()
        if t == GeomAbs_Line:
            info.update(dir=_vec(ad.Line().Direction()))
        elif t == GeomAbs_Circle:
            c = ad.Circle()
            info.update(radius=c.Radius(), center=_xyz(c.Location()), axis=dict(point=_xyz(c.Location()), dir=_vec(c.Axis().Direction())),
                        closed=sub.IsClosed())
    return info, sub


def _foot_on_line(p, q, d):
    """Lotfusspunkt von p auf die Gerade durch q mit Richtung d."""
    along = _dot(_sub(p, q), d) / _dot(d, d)
    return [round(q[k] + along * d[k], 6) for k in range(3)]


def _point_to(v, o):
    """Ein Punkt und ein anderes Element: Abstand zur Ebene, zur Achse oder zur Geraden (jeweils unbegrenzt gedacht)."""
    p = v["point"]
    if o.get("normal") and o.get("origin"):
        n = o["normal"]
        s = _dot(_sub(p, o["origin"]), n) / _norm(n)
        foot = [round(p[k] - s * n[k] / _norm(n), 6) for k in range(3)]
        return "toPlane", dict(value=abs(s), p1=p, p2=foot)
    if o.get("axis"):
        foot = _foot_on_line(p, o["axis"]["point"], o["axis"]["dir"])
        return "toAxis", dict(value=_norm(_sub(p, foot)), p1=p, p2=foot)
    if o.get("dir") and o.get("start"):
        foot = _foot_on_line(p, o["start"], o["dir"])
        return "toLine", dict(value=_norm(_sub(p, foot)), p1=p, p2=foot)
    return None, None


def _axis_distance(a, b):
    """Abstand zweier paralleler Achsen und die Verbindung zwischen ihnen (in Hoehe des ersten Achspunkts)."""
    pa, d = a["point"], a["dir"]
    w = _sub(b["point"], pa)
    along = _dot(w, d) / _dot(d, d)
    foot = [b["point"][k] - along * d[k] for k in range(3)]  # Punkt auf Achse B auf Hoehe von pa
    return _norm(_sub(foot, pa)), pa, [round(x, 6) for x in foot]


def pair(ia, sa, ib, sb):
    """Abstaende und Winkel zwischen zwei Elementen. Welche Angabe die wichtigste ist, entscheidet die Oberflaeche."""
    out = {}
    value, p1, p2 = _dist(sa.wrapped, sb.wrapped)
    out["min"] = dict(value=value, p1=p1, p2=p2)
    if ia.get("point") and ib.get("point"):
        out["points"] = dict(value=_norm(_sub(ib["point"], ia["point"])), p1=ia["point"], p2=ib["point"],
                             delta=[round(ib["point"][k] - ia["point"][k], 6) for k in range(3)])
    va, vb = ia["kind"] == "vertex", ib["kind"] == "vertex"
    if va != vb:
        key, span = _point_to(ia, ib) if va else _point_to(ib, ia)
        if key:
            out[key] = span
        return out
    if va and vb:
        return out  # zwei Punkte: der Abstand steht schon in "points"
    na, nb = ia.get("normal"), ib.get("normal")
    da = ia.get("dir") or (ia.get("axis") or {}).get("dir")
    db = ib.get("dir") or (ib.get("axis") or {}).get("dir")
    if na and nb:
        ang = _angle(na, nb)
        par = ang < PARALLEL or abs(ang - math.pi) < PARALLEL
        out["angle"] = 0.0 if par else math.degrees(min(ang, math.pi - ang))
        if par:
            # Wandstaerke, Spaltmass: Abstand der Ebenen, gezeichnet als Lot vom angeklickten Punkt auf Ebene B
            start = ia.get("point") or ia["origin"]
            s = _dot(_sub(start, ib["origin"]), nb)
            foot = [round(start[k] - s * nb[k] / _dot(nb, nb), 6) for k in range(3)]
            out["planes"] = dict(value=abs(s) / _norm(nb), p1=start, p2=foot)
    elif ia.get("axis") and ib.get("axis"):
        ang = _angle(da, db)
        if ang < PARALLEL or abs(ang - math.pi) < PARALLEL:
            # Bohrungen, Wellen: Abstand der Achsen (bei Kreisen der Mittelpunkte in derselben Ebene)
            v, p1, p2 = _axis_distance(ia["axis"], ib["axis"])
            out["axes"] = dict(value=v, p1=p1, p2=p2)
        else:
            out["angle"] = math.degrees(min(ang, math.pi - ang))
    elif da and db:
        ang = _angle(da, db)
        out["angle"] = math.degrees(min(ang, math.pi - ang))
    elif (na and db) or (nb and da):
        n, d = (na, db) if na else (nb, da)
        out["angle"] = abs(90.0 - math.degrees(_angle(n, d)))  # Winkel zwischen Gerade/Achse und Ebene
        out["angle"] = min(out["angle"], 90.0)
    return out


def measure(model, req):
    ia, sa = describe(model, req["a"])
    res = dict(build=model.build, a=ia)
    if req.get("b"):
        ib, sb = describe(model, req["b"])
        res["b"] = ib
        res["pair"] = pair(ia, sa, ib, sb)
    return res


def serve(stdin=sys.stdin, stdout=sys.stdout):
    """Anfragen als JSON-Zeilen: {"id", "folder", "build", "a", "b"?}. Antwort: {"id", "ok", "result"|"error", "stale"?, "rebuilt"?}.
    Geladene Staende bleiben im Speicher, bis sich die Kennung in model.map.json aendert. {"prepare": true} statt "a" laedt
    nur den Stand (bei grossen Baugruppen dauert das), damit der erste Klick nicht darauf warten muss."""
    models = {}
    stdout.write(json.dumps(dict(ready=True)) + "\n")
    stdout.flush()
    for line in stdin:
        line = line.strip()
        if not line:
            continue
        rid = None
        try:
            req = json.loads(line)
            rid = req.get("id")
            folder = str(req["folder"])
            current = json.loads((Path(folder) / "model.map.json").read_text(encoding="utf-8")).get("build")
            if req.get("build") and req["build"] != current:
                raise MeasureError("The model has been rebuilt in the meantime. Please click again.", rebuilt=True)
            m = models.get(folder)
            if m is None or m.build != current:
                m = models[folder] = Model(folder)
            if req.get("prepare"):
                out = dict(id=rid, ok=True, result=dict(build=m.build, parts=len(m.shapes)))
            else:
                out = dict(id=rid, ok=True, result=measure(m, req))
        except MeasureError as e:
            out = dict(id=rid, ok=False, error=str(e), stale=e.stale, rebuilt=e.rebuilt)
        except Exception as e:  # nie abstuerzen: der Dienst bedient auch die naechste Anfrage
            out = dict(id=rid, ok=False, error=f"{type(e).__name__}: {e}")
        stdout.write(json.dumps(out) + "\n")
        stdout.flush()