Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

13.1 KB
Raw Blame
using System.Globalization;
using System.Security.Cryptography;
using System.Text;
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Brep.Tessellation;
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Visualization;

namespace Aetheris.Kernel.Firmament.Drawing;

internal sealed record DrawingProjectionBody(string OccurrenceIdentity, string DefinitionIdentity, BrepBody Body);

/// <summary>Exact B-rep edges plus a bounded display-mesh occlusion oracle. The mesh decides
/// only visibility intervals; it never replaces the authoritative edge geometry.</summary>
internal static class DrawingProjectionEngine
{
    private readonly record struct CameraPoint(double X, double Y, double Depth);
    private sealed record RawEdge(string Id, string Occurrence, string Definition, IReadOnlyList<CameraPoint> Points, bool Curved);
    private sealed record Triangle(CameraPoint A, CameraPoint B, CameraPoint C, string Identity);

    public static DrawingViewIr Project(
        IReadOnlyList<DrawingProjectionBody> bodies,
        string name,
        DrawingProjectionKind projection,
        DrawingHiddenLinePolicy hiddenPolicy,
        IReadOnlyList<double> directionSource,
        IReadOnlyList<string> pmi,
        DrawingRect viewport,
        DrawingLocationIr location)
    {
        var direction = Normalize(new Vector3D(directionSource[0], directionSource[1], directionSource[2]));
        var upCandidate = Math.Abs(direction.Z) > .9 ? new Vector3D(0, 1, 0) : new Vector3D(0, 0, 1);
        var right = Normalize(upCandidate.Cross(direction));
        var up = Normalize(direction.Cross(right));
        CameraPoint Camera(Point3D point) => new(
            point.X * right.X + point.Y * right.Y + point.Z * right.Z,
            point.X * up.X + point.Y * up.Y + point.Z * up.Z,
            point.X * direction.X + point.Y * direction.Y + point.Z * direction.Z);

        var raw = new List<RawEdge>();
        var triangles = new List<Triangle>();
        var unsupported = new List<string>();
        foreach (var projectionBody in bodies.OrderBy(body => body.OccurrenceIdentity, StringComparer.Ordinal))
        {
            var body = projectionBody.Body;
            var samples = BrepWireframeSvgRenderer.SampleGeometry(body, new(CurveSamples: 64, Density: 5));
            unsupported.AddRange(samples.Evidence.UnsupportedCurveFamilies.Select(kind => $"{projectionBody.OccurrenceIdentity}:curve:{kind}"));
            foreach (var line in samples.Boundaries)
            {
                var edge = body.Topology.Edges.Single(e => e.Id.Value == line.EdgeId);
                if (IsInternalSupportEdge(body, edge.Id)) continue;
                var curved = body.TryGetEdgeCurveGeometry(edge.Id, out var curve) && curve?.Kind != CurveGeometryKind.Line3;
                var points = curved ? line.Points : new[] { line.Points[0], line.Points[^1] };
                raw.Add(new(line.Identity, projectionBody.OccurrenceIdentity, projectionBody.DefinitionIdentity, points.Select(Camera).ToArray(), curved));
            }
            if (hiddenPolicy == DrawingHiddenLinePolicy.Wireframe)
            {
                if (projection == DrawingProjectionKind.Isometric)
                    foreach (var line in samples.Isolines)
                        raw.Add(new(line.Identity, projectionBody.OccurrenceIdentity, projectionBody.DefinitionIdentity, line.Points.Select(Camera).ToArray(), false));
                unsupported.AddRange(samples.Evidence.UnsupportedSurfaceFamilies.Select(kind => $"{projectionBody.OccurrenceIdentity}:surface:{kind}"));
                continue;
            }

            // The admitted tessellator is the deterministic support-family bound. Avoid a
            // wall-clock cutoff here: timeout-dependent partial patches would make DrawingIR
            // depend on machine load and violate reproducible HLR evidence.
            var meshResult = BrepDisplayTessellator.Tessellate(body);
            var mesh = meshResult.IsSuccess ? meshResult.Value : new DisplayTessellationResult([], [], meshResult.Diagnostics.Select(diagnostic =>
                new DisplayFaceMaterializationDiagnostic(null, null, "Tessellate", diagnostic.Source ?? diagnostic.Code.ToString(), diagnostic.Message)).ToArray());
            foreach (var diagnostic in mesh.FaceDiagnostics ?? [])
                unsupported.Add($"{projectionBody.OccurrenceIdentity}:face:{diagnostic.FaceId?.Value.ToString(CultureInfo.InvariantCulture) ?? "?"}:{diagnostic.SurfaceKind ?? diagnostic.Code}");
            foreach (var patch in mesh.FacePatches.OrderBy(patch => patch.FaceId.Value))
            for (var index = 0; index + 2 < patch.TriangleIndices.Count; index += 3)
            {
                var a = Camera(patch.Positions[patch.TriangleIndices[index]]);
                var b = Camera(patch.Positions[patch.TriangleIndices[index + 1]]);
                var c = Camera(patch.Positions[patch.TriangleIndices[index + 2]]);
                if (Math.Abs(Cross(a, b, c)) > 1e-12)
                    triangles.Add(new(a, b, c, $"{projectionBody.OccurrenceIdentity}:face:{patch.FaceId.Value}:triangle:{index / 3}"));
            }
        }
        if (raw.Count == 0) throw new InvalidOperationException("drawing-projection-no-exact-edges");

        var all = raw.SelectMany(edge => edge.Points).ToArray();
        var minX = all.Min(point => point.X); var maxX = all.Max(point => point.X);
        var minY = all.Min(point => point.Y); var maxY = all.Max(point => point.Y);
        var modelWidth = Math.Max(1e-9, maxX - minX); var modelHeight = Math.Max(1e-9, maxY - minY);
        var scale = Math.Min((viewport.Width - 24) / modelWidth, (viewport.Height - 24) / modelHeight);
        var originX = viewport.X + (viewport.Width - modelWidth * scale) / 2 - minX * scale;
        var originY = viewport.Y + (viewport.Height - modelHeight * scale) / 2 + maxY * scale;
        DrawingPoint2 Page(CameraPoint point) => new(originX + point.X * scale, originY - point.Y * scale);

        var primitives = new List<DrawingProjectedPrimitiveIr>();
        var candidateSegments = 0; var visibleSegments = 0; var hiddenSegments = 0; var splitPoints = 0;
        if (hiddenPolicy == DrawingHiddenLinePolicy.Wireframe)
        {
            foreach (var edge in raw.OrderBy(edge => edge.Occurrence, StringComparer.Ordinal).ThenBy(edge => edge.Id, StringComparer.Ordinal))
                primitives.Add(new($"{edge.Occurrence}:{edge.Id}:wireframe", edge.Id.StartsWith("face:", StringComparison.Ordinal) ? DrawingPrimitiveKind.SurfaceGrid : DrawingPrimitiveKind.Visible,
                    edge.Points.Select(Page).ToArray(), edge.Occurrence, edge.Points.Average(p => p.Depth), edge.Definition,
                    edge.Id.StartsWith("edge:", StringComparison.Ordinal) ? edge.Id : null));
            candidateSegments = raw.Sum(edge => edge.Points.Count - 1);
            visibleSegments = candidateSegments;
        }
        else foreach (var edge in raw.OrderBy(edge => edge.Occurrence, StringComparer.Ordinal).ThenBy(edge => edge.Id, StringComparer.Ordinal))
        for (var segment = 1; segment < edge.Points.Count; segment++)
        {
            candidateSegments++;
            var a = edge.Points[segment - 1]; var b = edge.Points[segment];
            var cuts = new List<double> { 0, 1 };
            foreach (var triangle in triangles)
            {
                AddIntersection(a, b, triangle.A, triangle.B, cuts);
                AddIntersection(a, b, triangle.B, triangle.C, cuts);
                AddIntersection(a, b, triangle.C, triangle.A, cuts);
            }
            var ordered = cuts.Where(value => value >= 0 && value <= 1).Order().Aggregate(new List<double>(), (values, value) =>
            { if (values.Count == 0 || Math.Abs(values[^1] - value) > 1e-8) values.Add(value); return values; });
            splitPoints += Math.Max(0, ordered.Count - 2);
            for (var interval = 1; interval < ordered.Count; interval++)
            {
                var from = ordered[interval - 1]; var to = ordered[interval];
                if (to - from < 1e-8) continue;
                var midpoint = Lerp(a, b, (from + to) / 2);
                var hidden = triangles.Any(triangle => Contains(triangle, midpoint.X, midpoint.Y, out var depth) && depth > midpoint.Depth + 1e-5);
                if (hidden) hiddenSegments++; else visibleSegments++;
                if (hidden && hiddenPolicy == DrawingHiddenLinePolicy.VisibleOnly) continue;
                var start = Lerp(a, b, from); var end = Lerp(a, b, to);
                var kind = hidden ? DrawingPrimitiveKind.Hidden : edge.Curved ? DrawingPrimitiveKind.Silhouette : DrawingPrimitiveKind.Visible;
                var stable = $"{edge.Occurrence}:{edge.Id}:segment:{segment - 1}:interval:{interval - 1}:{kind}";
                primitives.Add(new(stable, kind, [Page(start), Page(end)], edge.Occurrence, (start.Depth + end.Depth) / 2,
                    edge.Definition, edge.Id));
            }
        }

        var geometryBounds = new DrawingRect(originX + minX * scale, originY - maxY * scale, modelWidth * scale, modelHeight * scale);
        var anchors = pmi.ToDictionary(reference => reference, _ => geometryBounds.Center, StringComparer.Ordinal);
        var evidenceSource = string.Join("|", primitives.Select(item => item.StableId)) + $"|{candidateSegments}|{visibleSegments}|{hiddenSegments}|{splitPoints}|{triangles.Count}";
        var hash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(evidenceSource))).ToLowerInvariant();
        var evidence = new DrawingVisibilityEvidenceIr(candidateSegments, visibleSegments, hiddenSegments, splitPoints, triangles.Count,
            unsupported.Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal).ToArray(),
            hiddenPolicy == DrawingHiddenLinePolicy.Wireframe ? "Trimmed BRep curves with optional sampled surface isolines; rear edges retained; no hidden-line classification."
                : "Exact B-rep edge intervals classified against deterministic bounded face triangles; depth epsilon 1e-5 mm.", hash);
        return new DrawingViewIr(name, projection, hiddenPolicy, new(direction.X, direction.Y), directionSource, viewport, geometryBounds, scale,
            primitives, anchors, pmi, location, evidence)
        { Camera = new([right.X, right.Y, right.Z], [up.X, up.Y, up.Z], originX, originY) };
    }

    private static void AddIntersection(CameraPoint a, CameraPoint b, CameraPoint c, CameraPoint d, List<double> values)
    {
        var rx = b.X - a.X; var ry = b.Y - a.Y; var sx = d.X - c.X; var sy = d.Y - c.Y;
        var denominator = rx * sy - ry * sx;
        if (Math.Abs(denominator) < 1e-12) return;
        var qx = c.X - a.X; var qy = c.Y - a.Y;
        var t = (qx * sy - qy * sx) / denominator;
        var u = (qx * ry - qy * rx) / denominator;
        if (t > 1e-8 && t < 1 - 1e-8 && u >= -1e-8 && u <= 1 + 1e-8) values.Add(t);
    }

    private static bool Contains(Triangle triangle, double x, double y, out double depth)
    {
        var area = Cross(triangle.A, triangle.B, triangle.C);
        var p = new CameraPoint(x, y, 0);
        var wa = Cross(p, triangle.B, triangle.C) / area;
        var wb = Cross(triangle.A, p, triangle.C) / area;
        var wc = 1 - wa - wb;
        depth = wa * triangle.A.Depth + wb * triangle.B.Depth + wc * triangle.C.Depth;
        return wa >= -1e-9 && wb >= -1e-9 && wc >= -1e-9;
    }

    private static double Cross(CameraPoint a, CameraPoint b, CameraPoint c) => (b.X - a.X) * (c.Y - a.Y) - (b.Y - a.Y) * (c.X - a.X);
    private static CameraPoint Lerp(CameraPoint a, CameraPoint b, double t) => new(a.X + (b.X - a.X) * t, a.Y + (b.Y - a.Y) * t, a.Depth + (b.Depth - a.Depth) * t);
    private static Vector3D Normalize(Vector3D vector) { var length = Math.Sqrt(vector.Dot(vector)); if (length < 1e-12) throw new InvalidOperationException("drawing-view-direction-zero"); return vector * (1 / length); }

    private static bool IsInternalSupportEdge(BrepBody body, Aetheris.Kernel.Core.Topology.EdgeId edgeId)
    {
        var loopIds = body.Topology.Coedges.Where(coedge => coedge.EdgeId == edgeId).Select(coedge => coedge.LoopId).ToHashSet();
        var faces = body.Topology.Faces.Where(face => face.LoopIds.Any(loopIds.Contains)).ToArray();
        if (faces.Length != 2) return false;
        if (!body.TryGetFaceSurfaceGeometry(faces[0].Id, out var first) || !body.TryGetFaceSurfaceGeometry(faces[1].Id, out var second)) return false;
        if (first?.Plane is { } a && second?.Plane is { } b)
            return Math.Abs(Math.Abs(a.Normal.ToVector().Dot(b.Normal.ToVector())) - 1) < 1e-8
                && Math.Abs((b.Origin - a.Origin).Dot(a.Normal.ToVector())) < 1e-7;
        if (first?.Cylinder is { } ca && second?.Cylinder is { } cb)
        {
            var axis = ca.Axis.ToVector(); var delta = cb.Origin - ca.Origin;
            return Math.Abs(ca.Radius - cb.Radius) < 1e-7 && axis.Cross(cb.Axis.ToVector()).Length < 1e-8
                && (delta - axis * delta.Dot(axis)).Length < 1e-7;
        }
        if (first?.Cone is { } sa && second?.Cone is { } sb)
            return Math.Abs(sa.SemiAngleRadians - sb.SemiAngleRadians) < 1e-8 && (sa.Apex - sb.Apex).Length < 1e-7
                && sa.Axis.ToVector().Dot(sb.Axis.ToVector()) > 1 - 1e-8;
        return false;
    }
}