Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

8.4 KB
Raw Blame
using System.Text.Json.Serialization;
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Brep.Tessellation;
using Aetheris.Kernel.Core.Topology;

namespace Aetheris.Kernel.Core.Import;

[JsonConverter(typeof(JsonStringEnumConverter<ImportQualificationStatus>))]
public enum ImportQualificationStatus { Qualified, Inspectable, Degraded, Failed }

[JsonConverter(typeof(JsonStringEnumConverter<ImportDisplayStatus>))]
public enum ImportDisplayStatus { NotAssessed, Complete, RefinementLimited, Partial }

public sealed record ImportQualificationReason(string Code, string Message, int? FaceId = null, int? StepEntityId = null);
public sealed record ImportedShellQualification(int ShellId, int FaceCount, int ConnectedComponents, int BoundaryEdges, int NonManifoldEdges, bool Enclosed);
public sealed record BrepImportQualificationReport(
    ImportQualificationStatus Status,
    ImportQualificationStatus GeometryStatus,
    int ExpectedFaces,
    int BoundFaces,
    int? DisplayedFaces,
    int MissingPcurves,
    double? SourceDistanceAccuracyMillimetres,
    double PcurveToleranceMillimetres,
    BrepPcurveEvidence PcurveEvidence,
    IReadOnlyList<ImportedShellQualification> Shells,
    IReadOnlyList<ImportQualificationReason> Reasons)
{
    public ImportDisplayStatus DisplayStatus { get; init; } = ImportDisplayStatus.NotAssessed;
    public IReadOnlyList<ImportQualificationReason> DisplayReasons { get; init; } = [];
    /// <summary>Disclosed deterministic source repairs, separate from qualification failures.</summary>
    public IReadOnlyList<ImportQualificationReason> Repairs { get; init; } = [];
}

/// <summary>Import evidence is separate from parser success and from display preparation.</summary>
public static class BrepImportQualification
{
    internal static BrepImportQualificationReport Evaluate(BrepBody body, int expectedFaces,
        double? sourceAccuracy, double pcurveTolerance, BrepPcurveEvidence? pcurveEvidence = null)
    {
        var reasons = new List<ImportQualificationReason>();
        var topology = body.Topology;
        var faces = topology.Faces.ToArray();
        var faceByLoop = faces.SelectMany(f => f.LoopIds.Select(l => (Loop: l, Face: f.Id))).ToDictionary(p => p.Loop, p => p.Face);
        var uses = topology.Coedges.GroupBy(c => c.EdgeId).ToDictionary(g => g.Key, g => g.Select(c => faceByLoop[c.LoopId]).ToArray());
        var shells = new List<ImportedShellQualification>();
        foreach (var shell in topology.Shells.OrderBy(s => s.Id.Value))
        {
            var set = shell.FaceIds.ToHashSet();
            var adjacency = set.ToDictionary(f => f, _ => new HashSet<FaceId>());
            var boundary = 0;
            var nonManifold = 0;
            foreach (var incidence in uses.Values)
            {
                var local = incidence.Where(set.Contains).ToArray();
                if (local.Length == 0) continue;
                if (local.Length == 1) boundary++;
                if (local.Length > 2) nonManifold++;
                foreach (var a in local) foreach (var b in local) if (a != b) adjacency[a].Add(b);
            }
            var unseen = set.ToHashSet();
            var components = 0;
            while (unseen.Count > 0)
            {
                components++;
                var queue = new Queue<FaceId>();
                var first = unseen.First();
                unseen.Remove(first); queue.Enqueue(first);
                while (queue.TryDequeue(out var current))
                    foreach (var next in adjacency[current]) if (unseen.Remove(next)) queue.Enqueue(next);
            }
            var resolved = body.FaceOrientationReport?.Shells.SingleOrDefault(s => s.ShellId == shell.Id);
            var enclosed = set.Count > 0 && components == 1 && boundary == 0 && nonManifold == 0 && resolved?.IsClosedManifold == true;
            shells.Add(new(shell.Id.Value, set.Count, components, boundary, nonManifold, enclosed));
            if (!enclosed) reasons.Add(new("incomplete-shell", $"Shell {shell.Id.Value}: components={components}, boundaryEdges={boundary}, nonManifoldEdges={nonManifold}, orientationEnclosed={resolved?.IsClosedManifold}."));
            if (resolved?.Qualification != FaceOrientationQualification.DerivedQualified)
                reasons.Add(new("unqualified-orientation", $"Shell {shell.Id.Value}: {resolved?.Qualification.ToString() ?? "not-assessed"}."));
        }
        if (faces.Length != expectedFaces) reasons.Add(new("face-count-mismatch", $"Expected {expectedFaces} faces; bound {faces.Length}."));
        foreach (var face in faces)
            if (!body.TryGetFaceSurface(face.Id, out var surface) || surface is null)
                reasons.Add(new("unbound-face", $"Face {face.Id.Value} has no support geometry.", face.Id.Value));
        // Distinct coincident vertex IDs are legal interchange topology. Measure the
        // directed gap without mutating vertices or broadening the recovery budget.
        var closureTolerance = double.Max(1e-6, sourceAccuracy ?? 0d);
        foreach (var loop in topology.Loops.Where(l => l.Kind == LoopKind.Edge))
        {
            for (var i = 0; i < loop.CoedgeIds.Count; i++)
            {
                var c = topology.GetCoedge(loop.CoedgeIds[i]);
                var n = topology.GetCoedge(loop.CoedgeIds[(i + 1) % loop.CoedgeIds.Count]);
                var e = topology.GetEdge(c.EdgeId); var ne = topology.GetEdge(n.EdgeId);
                var end = DirectedEdgeUse.Resolve(e, c).EndVertexId;
                var start = DirectedEdgeUse.Resolve(ne, n).StartVertexId;
                if (end == start) continue;
                var gap = body.TryGetVertexPoint(end, out var p) && body.TryGetVertexPoint(start, out var q) ? (p - q).Length : double.PositiveInfinity;
                if (gap > closureTolerance) reasons.Add(new("trim-loop-not-closed", $"Loop {loop.Id.Value}, coedges {c.Id.Value}->{n.Id.Value}: gap={gap:R} mm, tolerance={closureTolerance:R} mm.", faceByLoop[loop.Id].Value));
            }
        }
        var evidence = pcurveEvidence ?? BrepPcurveValidator.Validate(body, pcurveTolerance);
        var missing = topology.Coedges.Count(c => !body.Bindings.TryGetPcurveBinding(c.Id, out _));
        foreach (var message in evidence.Diagnostics) reasons.Add(new("invalid-pcurve", message));
        foreach (var d in body.PcurveRecoveryReport?.Diagnostics ?? []) reasons.Add(new("pcurve-recovery-failed", d.Message));
        var degraded = reasons.Count > 0;
        if (missing > 0) reasons.Add(new("missing-pcurve", $"{missing} coedges lack qualified face-local trim bindings."));
        var geometryStatus = faces.Length == 0 ? ImportQualificationStatus.Failed : degraded ? ImportQualificationStatus.Degraded
            : missing > 0 ? ImportQualificationStatus.Inspectable : ImportQualificationStatus.Qualified;
        return new(geometryStatus,
            geometryStatus, expectedFaces, faces.Length, null, missing, sourceAccuracy, pcurveTolerance, evidence, shells, reasons);
    }

    /// <summary>Projects actual display evidence; it never repairs or adds geometry.</summary>
    public static BrepImportQualificationReport WithDisplay(BrepBody body, DisplayTessellationResult mesh)
    {
        var report = body.ImportQualification ?? Evaluate(body, body.Topology.Faces.Count(), null, 1e-3);
        var displayed = mesh.FacePatches.Where(p => p.TriangleIndices.Count > 0).Select(p => p.FaceId).ToHashSet();
        var reasons = new List<ImportQualificationReason>();
        foreach (var face in body.Topology.Faces.Where(f => !displayed.Contains(f.Id)))
        {
            body.Bindings.TryGetFaceBinding(face.Id, out var binding);
            body.TryGetFaceSurface(face.Id, out var support);
            reasons.Add(new("missing-display-face", $"Face {face.Id.Value} ({support?.Kind}) produced no display triangles.", face.Id.Value, binding.SourceStepEntityId));
        }
        foreach (var d in mesh.FaceDiagnostics ?? [])
            reasons.Add(new(d.Code, d.Message, d.FaceId?.Value,
                d.FaceId is { } faceId && body.Bindings.TryGetFaceBinding(faceId, out var binding) ? binding.SourceStepEntityId : null));
        var displayStatus = displayed.Count < report.BoundFaces ? ImportDisplayStatus.Partial
            : reasons.Count > 0 ? ImportDisplayStatus.RefinementLimited : ImportDisplayStatus.Complete;
        return report with { Status = report.GeometryStatus, DisplayedFaces = displayed.Count,
            DisplayStatus = displayStatus, DisplayReasons = reasons };
    }
}