Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

5.7 KB
Raw Blame
using Aetheris.Kernel.Core.Math;

namespace Aetheris.Kernel.Core.Brep.Tessellation;

/// <summary>Final derived triangle-only mesh.  It deliberately has no B-rep or trim knowledge.</summary>
public sealed record TriangleMesh(
    IReadOnlyList<Point3D> Positions,
    IReadOnlyList<Vector3D> Normals,
    IReadOnlyList<int> TriangleIndices,
    IReadOnlySet<(int A, int B)> HardEdges,
    string DeterministicHash);

public sealed record TriangleMeshTopologyReport(
    bool IsWatertight,
    bool IsConnected,
    bool IsOutwardOriented,
    int CrackCount,
    int NonManifoldEdgeCount,
    int DuplicateTriangleCount,
    int ZeroAreaTriangleCount,
    int TriangleCount,
    int VertexCount,
    double SignedVolume)
{
    public int OrientationConflictEdgeCount { get; init; }
    public bool IsConsistentlyOriented { get; init; }
    public bool HasValidSignedVolume { get; init; }
}

public static class TriangleMeshValidator
{
    private const double AreaEpsilon = 1e-18d;

    public static bool TryValidateClosed(TriangleMesh mesh, out TriangleMeshTopologyReport report, out string? failure)
    {
        var edges = new Dictionary<(int A, int B), (int Count, int Balance)>();
        var triangles = new HashSet<(int A, int B, int C)>();
        var zero = 0; var duplicate = 0;
        if (mesh.Positions.Any(p => !double.IsFinite(p.X) || !double.IsFinite(p.Y) || !double.IsFinite(p.Z)))
        { failure = "Triangle mesh contains a nonfinite position."; report = Empty(mesh); return false; }
        for (var i = 0; i < mesh.TriangleIndices.Count; i += 3)
        {
            if (i + 2 >= mesh.TriangleIndices.Count) { failure = "Triangle index buffer is not a multiple of three."; report = Empty(mesh); return false; }
            var a = mesh.TriangleIndices[i]; var b = mesh.TriangleIndices[i + 1]; var c = mesh.TriangleIndices[i + 2];
            if (a < 0 || b < 0 || c < 0 || a >= mesh.Positions.Count || b >= mesh.Positions.Count || c >= mesh.Positions.Count) { failure = "Triangle references an invalid vertex."; report = Empty(mesh); return false; }
            var canonical = new[] { a, b, c }; Array.Sort(canonical);
            if (!triangles.Add((canonical[0], canonical[1], canonical[2]))) duplicate++;
            if (((mesh.Positions[b] - mesh.Positions[a]).Cross(mesh.Positions[c] - mesh.Positions[a])).Length <= AreaEpsilon) zero++;
            AddEdge(a, b); AddEdge(b, c); AddEdge(c, a);
        }
        var cracks = edges.Count(pair => pair.Value.Count == 1);
        var nonmanifold = edges.Count(pair => pair.Value.Count != 2);
        var conflicts = edges.Count(pair => pair.Value.Count == 2 && pair.Value.Balance != 0);
        var connected = IsConnected(mesh);
        var volume = SignedVolume(mesh);
        var consistent = cracks == 0 && nonmanifold == 0 && conflicts == 0;
        var validVolume = consistent && connected && duplicate == 0 && zero == 0 && double.IsFinite(volume);
        var outward = validVolume && volume > 0d;
        report = new TriangleMeshTopologyReport(outward, connected, outward, cracks, nonmanifold, duplicate, zero,
            mesh.TriangleIndices.Count / 3, mesh.Positions.Count, volume)
        { OrientationConflictEdgeCount = conflicts, IsConsistentlyOriented = consistent, HasValidSignedVolume = validVolume };
        failure = report.IsWatertight ? null : $"Triangle mesh topology failed: cracks={cracks}, nonmanifold={nonmanifold}, orientationConflicts={conflicts}, duplicates={duplicate}, zeroArea={zero}, connected={connected}, signedVolumeValid={validVolume}, signedVolume={volume:R}.";
        return report.IsWatertight;

        void AddEdge(int x, int y)
        {
            var edge = x < y ? (x, y) : (y, x);
            var old = edges.GetValueOrDefault(edge);
            edges[edge] = (old.Count + 1, old.Balance + (x < y ? 1 : -1));
        }
    }

    private static TriangleMeshTopologyReport Empty(TriangleMesh mesh) => new(false, false, false, 0, 0, 0, 0, mesh.TriangleIndices.Count / 3, mesh.Positions.Count, 0d);

    private static bool IsConnected(TriangleMesh mesh)
    {
        if (mesh.TriangleIndices.Count == 0) return false;
        var adjacency = new Dictionary<int, HashSet<int>>();
        for (var i = 0; i < mesh.TriangleIndices.Count; i += 3)
        {
            for (var j = 0; j < 3; j++)
            {
                var a = mesh.TriangleIndices[i + j]; var b = mesh.TriangleIndices[i + ((j + 1) % 3)];
                if (!adjacency.TryGetValue(a, out var linked)) adjacency[a] = linked = [];
                linked.Add(b);
                if (!adjacency.TryGetValue(b, out linked)) adjacency[b] = linked = [];
                linked.Add(a);
            }
        }
        var seen = new HashSet<int>(); var pending = new Stack<int>(); pending.Push(adjacency.Keys.Min());
        while (pending.Count > 0) foreach (var next in adjacency[pending.Pop()]) if (seen.Add(next)) pending.Push(next);
        return seen.Count == adjacency.Count;
    }

    private static double SignedVolume(TriangleMesh mesh)
    {
        if (mesh.Positions.Count == 0) return 0;
        // A nearby anchor avoids cancellation for closed parts far from world
        // zero. This is numerical conditioning, not a closure/orientation proof.
        var origin = mesh.Positions[0];
        var volume = 0d; var compensation = 0d;
        for (var i = 0; i < mesh.TriangleIndices.Count; i += 3)
        {
            var a = mesh.Positions[mesh.TriangleIndices[i]]; var b = mesh.Positions[mesh.TriangleIndices[i + 1]]; var c = mesh.Positions[mesh.TriangleIndices[i + 2]];
            var term = (a - origin).Dot((b - origin).Cross(c - origin)) / 6d;
            var corrected = term - compensation;
            var next = volume + corrected;
            compensation = (next - volume) - corrected;
            volume = next;
        }
        return volume;
    }
}