Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

22.7 KB
Raw Blame
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Geometry.Curves;
using Aetheris.Kernel.Core.Geometry.Surfaces;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Topology;
using Rhino.Geometry;
using KernelPoint = Aetheris.Kernel.Core.Math.Point3D;

namespace Aetheris.ThreeDm;

public sealed record ThreeDmBoundBody(
    int ObjectIndex, Guid SourceId, BrepBody? Body, int SourceFaces, int SourceTrims,
    int BoundFaces, int BoundTrims, int SourcePcurves, int RecoveredPcurves,
    double WorstPcurveResidualMillimetres, IReadOnlyList<string> Diagnostics)
{
    public bool IsQualified => Body is not null && Diagnostics.Count == 0;
    public IReadOnlyList<ThreeDmTopologyAdjustment> Adjustments { get; init; } = [];
    public IReadOnlyDictionary<VertexId, double> SourceVertexTolerancesMillimetres { get; init; } =
        new Dictionary<VertexId, double>();
}

public sealed record ThreeDmTopologyAdjustment(
    string Kind, int SourceIndex, double BeforeMillimetres, double AfterMillimetres,
    double AllowedMillimetres, string Explanation);

/// <summary>Import-only topology bridge. Source edge and trim indices remain in diagnostics.</summary>
public static class ThreeDmBrepBinder
{
    public static ThreeDmBoundBody Bind(Brep source, int objectIndex, Guid sourceId,
        double millimetresPerUnit, double recoveryToleranceMillimetres)
    {
        var diagnostics = new List<string>();
        var builder = new TopologyBuilder();
        var geometry = new BrepGeometryStore();
        var bindings = new BrepBindingModel();
        var vertexPoints = new Dictionary<VertexId, KernelPoint>();
        var vertices = new Dictionary<int, VertexId>();
        var edges = new Dictionary<int, EdgeId>();
        var faces = new List<FaceId>();
        var boundTrims = 0;
        var sourcePcurves = 0;
        var adjustments = new List<ThreeDmTopologyAdjustment>();
        var endpointCandidates = new Dictionary<int, List<KernelPoint>>();
        var vertexTolerances = new Dictionary<VertexId, double>();
        var singularTransitions = new HashSet<(CoedgeId Current, CoedgeId Next)>();

        try
        {
            foreach (var vertex in source.Vertices)
            {
                var id = builder.AddVertex();
                vertices.Add(vertex.VertexIndex, id);
                vertexPoints.Add(id, ToPoint(vertex.Location, millimetresPerUnit));
                vertexTolerances.Add(id, double.IsFinite(vertex.Tolerance)
                    ? double.Min(1d, double.Max(0d, vertex.Tolerance * millimetresPerUnit)) : 0d);
            }
            foreach (var edge in source.Edges)
            {
                if (edge.StartVertex is null || edge.EndVertex is null)
                    return Failed($"object:{objectIndex}/edge:{edge.EdgeIndex}: endpoint vertex missing.");
                var id = builder.AddEdge(vertices[edge.StartVertex.VertexIndex], vertices[edge.EndVertex.VertexIndex]);
                edges.Add(edge.EdgeIndex, id);
                var curve = BindCurve(edge, sourceId, millimetresPerUnit, recoveryToleranceMillimetres,
                    out var interval, out var reason);
                if (curve is null) return Failed($"object:{objectIndex}/edge:{edge.EdgeIndex}: {reason}");
                var geometryId = new CurveGeometryId(edge.EdgeIndex + 1);
                geometry.AddCurve(geometryId, curve);
                bindings.AddEdgeBinding(new(id, geometryId, interval));
                AddEndpoint(edge.StartVertex.VertexIndex, EvaluateCurve(curve, interval.Start));
                AddEndpoint(edge.EndVertex.VertexIndex, EvaluateCurve(curve, interval.End));
            }
            foreach (var vertex in source.Vertices)
            {
                if (!endpointCandidates.TryGetValue(vertex.VertexIndex, out var candidates) || candidates.Count == 0) continue;
                var id = vertices[vertex.VertexIndex];
                var original = vertexPoints[id];
                var before = candidates.Max(point => (point - original).Length);
                if (before <= 1e-6d) continue;
                var anchor = candidates[0];
                var after = candidates.Max(point => (point - anchor).Length);
                var sourceLimit = double.IsFinite(vertex.Tolerance) && vertex.Tolerance > 0
                    ? vertex.Tolerance * millimetresPerUnit : recoveryToleranceMillimetres;
                // Source vertex tolerance is topology evidence, distinct from spline recovery error.
                // Cap it locally; never change the kernel or authored tolerance.
                var allowed = double.Max(recoveryToleranceMillimetres, double.Min(1d, sourceLimit));
                if (before > allowed || after > 1e-6d) continue;
                vertexPoints[id] = anchor;
                adjustments.Add(new("SourceVertexToCoincidentEdgeEndpoints", vertex.VertexIndex,
                    before, after, allowed, "All incident bound edge endpoints agree; source vertex is within its declared tolerance."));
            }

            foreach (var face in source.Faces)
            {
                var surface = BindSurface(source.Surfaces[face.SurfaceIndex], sourceId, face.FaceIndex, millimetresPerUnit,
                    recoveryToleranceMillimetres, out var reason);
                if (surface is null) return Failed($"object:{objectIndex}/face:{face.FaceIndex}: {reason}");
                var loops = new List<LoopId>();
                var pendingPcurves = new List<(CoedgeId Id, BrepTrim Trim)>();
                foreach (var loop in face.Loops)
                {
                    if (loop.Trims.Count == 0) return Failed($"object:{objectIndex}/face:{face.FaceIndex}/loop:{loop.LoopIndex}: empty loop.");
                    foreach (var trim in loop.Trims.Where(trim => trim.Edge is null))
                    {
                        if (trim.TrimType != BrepTrimType.Singular || trim.StartVertex is null ||
                            trim.StartVertex.VertexIndex != trim.EndVertex?.VertexIndex || trim.TrimCurve is null)
                            return Failed($"object:{objectIndex}/face:{face.FaceIndex}/loop:{loop.LoopIndex}/trim:{trim.TrimIndex}: edgeless trim is not a qualified singular vertex use.");
                        var vertex = trim.StartVertex;
                        var original = ToPoint(vertex.Location, millimetresPerUnit);
                        var domain = trim.Domain;
                        var worst = 0d;
                        for (var sample = 0; sample <= 32; sample++)
                        {
                            var uv = trim.PointAt(domain.T0 + (domain.T1 - domain.T0) * sample / 32d);
                            var lifted = ToPoint(source.Surfaces[face.SurfaceIndex].PointAt(uv.X, uv.Y), millimetresPerUnit);
                            worst = double.Max(worst, (lifted - original).Length);
                        }
                        // Rhino's declared vertex tolerance is source topology evidence, capped locally.
                        var allowed = double.Max(recoveryToleranceMillimetres,
                            double.Min(1d, double.IsFinite(vertex.Tolerance) ? double.Max(0d, vertex.Tolerance * millimetresPerUnit) : 0d));
                        if (!double.IsFinite(worst) || worst > allowed)
                            return Failed($"object:{objectIndex}/face:{face.FaceIndex}/loop:{loop.LoopIndex}/trim:{trim.TrimIndex}: singular lift {worst:G9} mm exceeds source-local bound {allowed:G9} mm.");
                        adjustments.Add(new("RhinoSingularTrimCollapsedToVertex", trim.TrimIndex, worst, 0d,
                            allowed, $"Face {face.FaceIndex}, loop {loop.LoopIndex}, source vertex {vertex.VertexIndex}; no 3D edge exists."));
                    }
                    var edgeTrims = loop.Trims.Where(trim => trim.Edge is not null).ToArray();
                    if (edgeTrims.Length == 0)
                        return Failed($"object:{objectIndex}/face:{face.FaceIndex}/loop:{loop.LoopIndex}: standalone singular vertex loop requires a supported collapsed analytic surface.");
                    for (var i = 0; i < edgeTrims.Length; i++)
                    {
                        var previous = edgeTrims[i];
                        var next = edgeTrims[(i + 1) % edgeTrims.Length];
                        if (previous.EndVertex?.VertexIndex != next.StartVertex?.VertexIndex)
                            return Failed($"object:{objectIndex}/face:{face.FaceIndex}/loop:{loop.LoopIndex}/trim:{previous.TrimIndex}: chain ends at vertex {previous.EndVertex?.VertexIndex}, next trim {next.TrimIndex} starts at {next.StartVertex?.VertexIndex}.");
                    }
                    var loopId = builder.AllocateLoopId();
                    var coedges = edgeTrims.Select(_ => builder.AllocateCoedgeId()).ToArray();
                    var edgePositions = Enumerable.Range(0, loop.Trims.Count).Where(index => loop.Trims[index].Edge is not null).ToArray();
                    for (var i = 0; i < edgePositions.Length; i++)
                        if ((edgePositions[(i + 1) % edgePositions.Length] - edgePositions[i] + loop.Trims.Count) % loop.Trims.Count != 1)
                            singularTransitions.Add((coedges[i], coedges[(i + 1) % coedges.Length]));
                    for (var i = 0; i < coedges.Length; i++)
                    {
                        var trim = edgeTrims[i];
                        builder.AddCoedge(new Coedge(coedges[i], edges[trim.Edge!.EdgeIndex], loopId,
                            coedges[(i + 1) % coedges.Length], coedges[(i + coedges.Length - 1) % coedges.Length],
                            trim.IsReversed()));
                        pendingPcurves.Add((coedges[i], trim));
                        boundTrims++;
                    }
                    boundTrims += loop.Trims.Count - edgeTrims.Length;
                    builder.AddLoop(new Loop(loopId, coedges));
                    loops.Add(loopId);
                }
                var faceId = builder.AddFace(loops);
                faces.Add(faceId);
                var surfaceId = new SurfaceGeometryId(face.FaceIndex + 1);
                geometry.AddSurface(surfaceId, surface);
                bindings.AddFaceBinding(new FaceGeometryBinding(faceId, surfaceId, !face.OrientationIsReversed));
                for (var i = 0; i < loops.Count; i++)
                {
                    var role = face.Loops[i].LoopType == BrepLoopType.Inner ? FaceBoundaryRole.Inner : FaceBoundaryRole.Outer;
                    bindings.AddFaceBoundaryRoleBinding(new(faceId, loops[i], role));
                }
                foreach (var (coedgeId, trim) in pendingPcurves)
                {
                    if (surface.BSplineSurfaceWithKnots is null || trim.TrimCurve is null || trim.Edge is null)
                        continue;
                    var edgeBinding = bindings.GetEdgeBinding(edges[trim.Edge.EdgeIndex]);
                    if (edgeBinding.TrimInterval is not { } interval) continue;
                    var retained = TrySourcePcurve(trim, geometry.GetCurve(edgeBinding.CurveGeometryId),
                        surface.BSplineSurfaceWithKnots, interval, millimetresPerUnit,
                        recoveryToleranceMillimetres, out var residual);
                    if (retained is null) continue;
                    bindings.AddPcurveBinding(new(coedgeId, faceId, surfaceId, retained,
                        Qualification: new(PcurveBindingOrigin.SourceValidated, residual,
                            recoveryToleranceMillimetres, 1025, "RhinoTrimSamples", surface.Kind.ToString())));
                    sourcePcurves++;
                }
            }
            var shell = builder.AddShell(faces);
            builder.AddBody([shell]);
            var body = new BrepBody(builder.Model, geometry, bindings, vertexPoints);
            var graph = BrepBindingValidator.Validate(body);
            if (!graph.IsSuccess)
                return Failed($"object:{objectIndex}: {string.Join("; ", graph.Diagnostics.Select(item => item.Message))}");
            var recovered = BrepPcurveRecovery.Populate(builder.Model, geometry, bindings,
                tolerance: recoveryToleranceMillimetres);
            var pcurveEvidence = BrepPcurveValidator.Validate(body, recoveryToleranceMillimetres, requireEveryCoedge: true,
                sourceTopology: new(vertexTolerances, singularTransitions));
            if (!recovered.IsSuccess || !pcurveEvidence.IsValid)
                return Failed($"object:{objectIndex}: pcurve binding: {string.Join("; ", recovered.Diagnostics.Select(item => item.Message).Concat(pcurveEvidence.Diagnostics))}",
                    body, recovered.Count - sourcePcurves, recovered.MaximumResidual);
            return new(objectIndex, sourceId, body, source.Faces.Count, source.Trims.Count,
                faces.Count, boundTrims, sourcePcurves, recovered.Count - sourcePcurves,
                recovered.MaximumResidual, diagnostics)
                { Adjustments = adjustments, SourceVertexTolerancesMillimetres = vertexTolerances };
        }
        catch (Exception exception) when (exception is ArgumentException or InvalidOperationException or NotSupportedException or KeyNotFoundException)
        {
            return Failed($"object:{objectIndex}: {exception.GetType().Name}: {exception.Message}");
        }

        ThreeDmBoundBody Failed(string reason, BrepBody? body = null, int recoveredPcurves = 0, double worstResidual = 0)
        {
            diagnostics.Add(reason);
            return new(objectIndex, sourceId, body, source.Faces.Count, source.Trims.Count,
                faces.Count, boundTrims, sourcePcurves, recoveredPcurves, worstResidual, diagnostics)
                { Adjustments = adjustments, SourceVertexTolerancesMillimetres = vertexTolerances };
        }
        void AddEndpoint(int vertexIndex, KernelPoint point)
        {
            if (!endpointCandidates.TryGetValue(vertexIndex, out var points)) endpointCandidates[vertexIndex] = points = [];
            points.Add(point);
        }
    }

    private static KernelPoint EvaluateCurve(CurveGeometry curve, double parameter) => curve.Kind switch
    {
        CurveGeometryKind.Line3 => curve.Line3!.Value.Evaluate(parameter),
        CurveGeometryKind.Circle3 => curve.Circle3!.Value.Evaluate(parameter),
        CurveGeometryKind.BSpline3 => curve.BSpline3!.Value.Evaluate(parameter),
        _ => throw new NotSupportedException($"3DM bound curve {curve.Kind} has no endpoint evaluator.")
    };

    private static CurveGeometry? BindCurve(BrepEdge edge, Guid sourceId, double scale, double tolerance,
        out ParameterInterval interval, out string reason)
    {
        var domain = edge.Domain;
        interval = new(domain.T0, domain.T1);
        reason = string.Empty;
        if (edge.EdgeCurve.IsLinear())
        {
            var start = ToPoint(edge.PointAt(domain.T0), scale);
            var end = ToPoint(edge.PointAt(domain.T1), scale);
            if (!Direction3D.TryCreate(end - start, out var direction))
            { reason = "linear edge has coincident endpoints."; return null; }
            interval = new(0, (end - start).Length);
            return CurveGeometry.FromLine(new Line3Curve(start, direction));
        }
        if (edge.EdgeCurve.TryGetCircle(out var circle) || edge.EdgeCurve.TryGetArc(out var arc) && (circle = new Circle(arc.Plane, arc.Radius)).IsValid)
        {
            var start = edge.PointAt(domain.T0);
            var normal = circle.Normal;
            var radial = start - circle.Center;
            radial.Unitize();
            var tangent = Vector3d.CrossProduct(normal, radial);
            if (tangent * edge.TangentAt(domain.T0) < 0) normal = -normal;
            var geometry = new Circle3Curve(ToPoint(circle.Center, scale), ToDirection(normal),
                circle.Radius * scale, ToDirection(radial));
            var sweep = 2d * double.Pi;
            if (edge.StartVertex?.VertexIndex != edge.EndVertex?.VertexIndex)
            {
                var endRadial = edge.PointAt(domain.T1) - circle.Center;
                var midRadial = edge.PointAt((domain.T0 + domain.T1) * 0.5d) - circle.Center;
                var yAxis = Vector3d.CrossProduct(normal, radial);
                static double PositiveAngle(Vector3d x, Vector3d y, Vector3d vector)
                {
                    var angle = double.Atan2(vector * y, vector * x);
                    return angle < 0 ? angle + 2d * double.Pi : angle;
                }
                sweep = PositiveAngle(radial, yAxis, endRadial);
                if (PositiveAngle(radial, yAxis, midRadial) > sweep + 1e-8d) sweep += 2d * double.Pi;
            }
            interval = new(0, sweep);
            return CurveGeometry.FromCircle(geometry);
        }
        var source = edge.EdgeCurve.ToNurbsCurve();
        var polynomial = ThreeDmSplineRecovery.SourceCurve(source, scale);
        if (!source.IsRational) return CurveGeometry.FromBSpline(polynomial);
        var weights = Enumerable.Range(0, source.Points.Count).Select(i => source.Points[i].Weight).ToArray();
        if (!BSplineCurveRationalReduction.TryReduce(polynomial, weights, tolerance,
            out var reduced, out var deviation, out reason)) return null;
        interval = new(reduced.DomainStart, reduced.DomainEnd);
        return CurveGeometry.FromRecoveredBSpline(reduced,
            new SplineRecoveryProvenance("3DM_RATIONAL_EDGE", "AdaptiveCubic", tolerance,
                deviation, true, "Rhino analytic probes did not qualify.",
                SourceEntityIdentity: $"3dm:{sourceId}/edge:{edge.EdgeIndex}"));
    }

    private static SurfaceGeometry? BindSurface(Surface source, Guid sourceId, int faceIndex,
        double scale, double tolerance, out string reason)
    {
        reason = string.Empty;
        if (source.TryGetPlane(out var plane))
            return SurfaceGeometry.FromPlane(new Aetheris.Kernel.Core.Geometry.Surfaces.PlaneSurface(ToPoint(plane.Origin, scale),
                ToDirection(plane.Normal), ToDirection(plane.XAxis)));
        if (source.TryGetCylinder(out var cylinder))
            return SurfaceGeometry.FromCylinder(new CylinderSurface(ToPoint(cylinder.Center, scale),
                ToDirection(cylinder.Axis), cylinder.Radius * scale, ToDirection(cylinder.BasePlane.XAxis)));
        if (source.TryGetCone(out var cone) && double.Abs(cone.Height) > 1e-12d)
            return SurfaceGeometry.FromCone(new ConeSurface(ToPoint(cone.ApexPoint, scale),
                ToDirection(cone.Axis), double.Atan(double.Abs(cone.Radius / cone.Height)),
                ToDirection(cone.Plane.XAxis)));
        if (source.TryGetSphere(out var sphere))
            return SurfaceGeometry.FromSphere(new SphereSurface(ToPoint(sphere.Center, scale),
                ToDirection(sphere.EquatorialPlane.Normal), sphere.Radius * scale,
                ToDirection(sphere.EquatorialPlane.XAxis)));
        if (source.TryGetTorus(out var torus))
            return SurfaceGeometry.FromTorus(new TorusSurface(ToPoint(torus.Plane.Origin, scale),
                ToDirection(torus.Plane.Normal), torus.MajorRadius * scale,
                torus.MinorRadius * scale, ToDirection(torus.Plane.XAxis)));
        var nurbs = source.ToNurbsSurface();
        var spline = ThreeDmSplineRecovery.SourceSurface(nurbs, scale);
        if (!spline.IsRational) return SurfaceGeometry.FromBSplineSurfaceWithKnots(spline);
        if (!BSplineSurfaceRationalReduction.TryReduce(spline, tolerance,
            out var reduced, out var deviation, out reason) || reduced is null) return null;
        return SurfaceGeometry.FromRecoveredBSplineSurfaceWithKnots(reduced,
            new SplineRecoveryProvenance("3DM_RATIONAL_FACE", "AdaptiveGreville", tolerance,
                deviation, true, "Rhino analytic probes did not qualify.",
                SourceEntityIdentity: $"3dm:{sourceId}/face:{faceIndex}"));
    }

    private static PcurveGeometry? TrySourcePcurve(BrepTrim trim, CurveGeometry boundCurve,
        BSplineSurfaceWithKnots recovered, ParameterInterval interval, double scale,
        double tolerance, out double maximum)
    {
        maximum = 0;
        var uv = new SurfaceParameterPoint[1025];
        var domain = trim.Domain;
        for (var i = 0; i < uv.Length; i++)
        {
            var fraction = i / 1024d;
            var edge = trim.Edge!;
            var edgeDomain = edge.Domain;
            var edgeFraction = fraction;
            if (boundCurve.Circle3 is { } circle)
            {
                var angle = interval.Start + (interval.End - interval.Start) * fraction;
                var target = circle.Evaluate(angle);
                var targetSource = new Point3d(target.X / scale, target.Y / scale, target.Z / scale);
                edgeFraction = fraction == 1d ? 1d : ClosestParameterFraction(edge, targetSource);
            }
            var sourceFraction = trim.IsReversed() ? 1d - edgeFraction : edgeFraction;
            var point = trim.PointAt(domain.T0 + (domain.T1 - domain.T0) * sourceFraction);
            uv[i] = new(point.X, point.Y);
            var edgePoint = boundCurve.Circle3 is { } boundCircle
                ? boundCircle.Evaluate(interval.Start + (interval.End - interval.Start) * fraction)
                : ToPoint(edge.PointAt(edgeDomain.T0 + (edgeDomain.T1 - edgeDomain.T0) * fraction), scale);
            var lifted = recovered.Evaluate(point.X, point.Y);
            var residual = (lifted - edgePoint).Length;
            maximum = double.Max(maximum, residual);
            if (!double.IsFinite(maximum) || maximum > tolerance) return null;
        }
        return PcurveGeometry.Polyline(interval, uv);
    }

    private static KernelPoint ToPoint(Point3d source, double scale) =>
        new(source.X * scale, source.Y * scale, source.Z * scale);

    private static double ClosestParameterFraction(BrepEdge edge, Point3d target)
    {
        var domain = edge.Domain;
        var bestIndex = 0;
        var best = double.PositiveInfinity;
        for (var i = 0; i <= 64; i++)
        {
            var parameter = domain.T0 + (domain.T1 - domain.T0) * i / 64d;
            var distance = edge.PointAt(parameter).DistanceToSquared(target);
            if (distance < best) { best = distance; bestIndex = i; }
        }
        var lower = double.Max(0, bestIndex - 1) / 64d;
        var upper = double.Min(64, bestIndex + 1) / 64d;
        for (var i = 0; i < 24; i++)
        {
            var left = lower + (upper - lower) / 3d;
            var right = upper - (upper - lower) / 3d;
            var leftPoint = edge.PointAt(domain.T0 + (domain.T1 - domain.T0) * left);
            var rightPoint = edge.PointAt(domain.T0 + (domain.T1 - domain.T0) * right);
            if (leftPoint.DistanceToSquared(target) < rightPoint.DistanceToSquared(target)) upper = right;
            else lower = left;
        }
        return (lower + upper) / 2d;
    }
    private static Direction3D ToDirection(Vector3d source) =>
        Direction3D.Create(new Vector3D(source.X, source.Y, source.Z));
}