Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

14.6 KB
Raw Blame
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Topology;

namespace Aetheris.Kernel.Core.Brep;

public sealed record BrepPcurveEvidence(
    bool IsValid,
    int EdgeCount,
    int PcurveCount,
    double MaximumReconstructionDeviation,
    bool DomainValid,
    bool OrientationConsistent,
    IReadOnlyList<string> Diagnostics)
{
    public bool LoopClosureValid { get; init; }
    public double MaximumUvLoopClosure { get; init; }
    public double RootMeanSquareReconstructionDeviation { get; init; }
}

/// <summary>Source-local topology evidence for collapsed trim vertices; omitted by authored callers.</summary>
public sealed record BrepPcurveTopologyEvidence(
    IReadOnlyDictionary<VertexId, double> VertexTolerancesMillimetres,
    IReadOnlySet<(CoedgeId Current, CoedgeId Next)> CollapsedSingularTransitions);

/// <summary>Independently samples face-local pcurves against their shared 3D edge geometry.</summary>
public static class BrepPcurveValidator
{
    public static BrepPcurveEvidence Validate(BrepBody body, double tolerance = 1e-6, bool requireEveryCoedge = false, int samples = 67,
        BrepPcurveTopologyEvidence? sourceTopology = null)
    {
        ArgumentNullException.ThrowIfNull(body);
        if (!double.IsFinite(tolerance) || tolerance <= 0d) throw new ArgumentOutOfRangeException(nameof(tolerance));
        if (samples < 3) throw new ArgumentOutOfRangeException(nameof(samples));
        var diagnostics = new List<string>();
        var maximum = 0d;
        var domainValid = true;
        var orientationValid = true;
        var loopClosureValid = true;
        var maximumUvClosure = 0d;
        var squaredResidual = 0d;
        var residualSamples = 0;

        foreach (var coedge in body.Topology.Coedges.OrderBy(item => item.Id.Value))
        {
            var coedgeMaximum = 0d;
            if (!body.Bindings.TryGetPcurveBinding(coedge.Id, out var binding))
            {
                if (requireEveryCoedge) diagnostics.Add($"surf-pcurve-missing:coedge={coedge.Id.Value}");
                continue;
            }
            var bindingTolerance = binding.Qualification?.QualificationToleranceMillimetres ?? tolerance;
            var face = body.Topology.Faces.SingleOrDefault(candidate => candidate.LoopIds.Contains(coedge.LoopId));
            if (face is null || face.Id != binding.FaceId)
            {
                diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:owning-face-mismatch");
                continue;
            }
            if (!body.Bindings.TryGetFaceBinding(face.Id, out var faceBinding) || faceBinding.SurfaceGeometryId != binding.SurfaceGeometryId
                || !body.Geometry.TryGetSurface(binding.SurfaceGeometryId, out var surface) || surface is null
                || !body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var edgeBinding)
                || !body.Geometry.TryGetCurve(edgeBinding.CurveGeometryId, out var curve) || curve is null)
            {
                diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:binding-reference");
                continue;
            }
            var interval = edgeBinding.TrimInterval ?? binding.Pcurve.Domain;
            if (!FiniteOrdered(binding.Pcurve.Domain) || (binding.Pcurve.Points.Count == 0 && binding.Pcurve.PolynomialCurve is null))
            {
                domainValid = false;
                diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:domain");
                continue;
            }
            for (var index = 0; index < samples; index++)
            {
                var fraction = index / (double)(samples - 1);
                var parameter = interval.Start + ((interval.End - interval.Start) * fraction);
                var curveParameter = binding.SameSense ? parameter : interval.End - ((parameter - interval.Start));
                var uv = binding.Pcurve.Evaluate(curveParameter);
                if (!WithinSurfaceDomain(surface, uv, bindingTolerance))
                {
                    domainValid = false;
                    diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:surface-domain:u={uv.U:R}:v={uv.V:R}");
                    break;
                }
                var onSurface = Evaluate(surface, uv);
                var onCurve = Evaluate(curve, parameter);
                if (onSurface is null || onCurve is null)
                {
                    diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:unsupported-evaluator");
                    break;
                }
                coedgeMaximum = double.Max(coedgeMaximum, (onSurface.Value - onCurve.Value).Length);
                squaredResidual += (onSurface.Value - onCurve.Value).LengthSquared;
                residualSamples++;
            }
            maximum = double.Max(maximum, coedgeMaximum);
            if (coedgeMaximum > bindingTolerance)
                diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:face={face.Id.Value}:surface={surface.Kind}:curve={curve.Kind}:pcurve={binding.Pcurve.Kind}:deviation={coedgeMaximum:R}:tolerance={bindingTolerance:R}");

            // The coedge runs from its first vertex to its last. Which trim end that is depends on both the
            // coedge's use of the edge and the edge's sense along its curve (EDGE_CURVE same_sense).
            var runsAgainstCurve = coedge.IsReversed ^ !edgeBinding.OrientedEdgeSense;
            var startVertexId = coedge.IsReversed ? body.Topology.GetEdge(coedge.EdgeId).EndVertexId : body.Topology.GetEdge(coedge.EdgeId).StartVertexId;
            if (body.TryGetVertexPoint(startVertexId, out var start))
            {
                var parameter = runsAgainstCurve ? interval.End : interval.Start;
                var uv = binding.Pcurve.Evaluate(binding.SameSense ? parameter : interval.End - (parameter - interval.Start));
                var reconstructed = Evaluate(surface, uv);
                var vertexTolerance = sourceTopology?.VertexTolerancesMillimetres.GetValueOrDefault(startVertexId) ?? 0d;
                if (reconstructed is null || (reconstructed.Value - start).Length > double.Max(bindingTolerance, vertexTolerance))
                {
                    orientationValid = false;
                    diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:orientation");
                }
            }

            var edge = body.Topology.GetEdge(coedge.EdgeId);
            var endVertex = coedge.IsReversed ? edge.StartVertexId : edge.EndVertexId;
            if (body.TryGetVertexPoint(endVertex, out var endPoint))
            {
                var parameter = runsAgainstCurve ? interval.Start : interval.End;
                var uv = binding.Pcurve.Evaluate(binding.SameSense ? parameter : interval.End - (parameter - interval.Start));
                var reconstructed = Evaluate(surface, uv);
                var vertexTolerance = sourceTopology?.VertexTolerancesMillimetres.GetValueOrDefault(endVertex) ?? 0d;
                if (reconstructed is null || (reconstructed.Value - endPoint).Length > double.Max(bindingTolerance, vertexTolerance))
                {
                    orientationValid = false;
                    diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:end-orientation");
                }
            }

            var next = body.Topology.GetCoedge(coedge.NextCoedgeId);
            if (body.Bindings.TryGetPcurveBinding(next.Id, out var nextBinding)
                && body.Bindings.TryGetEdgeBinding(next.EdgeId, out var nextEdgeBinding)
                && nextEdgeBinding.TrimInterval is { } nextInterval)
            {
                var nextRunsAgainstCurve = next.IsReversed ^ !nextEdgeBinding.OrientedEdgeSense;
                var currentLoopParameter = runsAgainstCurve ? interval.Start : interval.End;
                var nextLoopParameter = nextRunsAgainstCurve ? nextInterval.End : nextInterval.Start;
                var currentUv = binding.Pcurve.Evaluate(binding.SameSense ? currentLoopParameter : interval.End - (currentLoopParameter - interval.Start));
                var nextUv = nextBinding.Pcurve.Evaluate(nextBinding.SameSense ? nextLoopParameter : nextInterval.End - (nextLoopParameter - nextInterval.Start));
                var closure = UvDistance(surface, currentUv, nextUv);
                maximumUvClosure = double.Max(maximumUvClosure, closure);
                // Two edges that each end within the source's vertex tolerance of their shared vertex may
                // stop up to twice that apart; in UV that is checked in model space below.
                var sharedVertex = runsAgainstCurve ? body.Topology.GetEdge(coedge.EdgeId).StartVertexId : body.Topology.GetEdge(coedge.EdgeId).EndVertexId;
                var sharedVertexTolerance = sourceTopology?.VertexTolerancesMillimetres.GetValueOrDefault(sharedVertex) ?? 0d;
                var closureTolerance = double.Max(bindingTolerance,
                    nextBinding.Qualification?.QualificationToleranceMillimetres ?? tolerance);
                if (sourceTopology?.CollapsedSingularTransitions.Contains((coedge.Id, next.Id)) == true)
                {
                    // The omitted Rhino singular trim crosses UV while lifting to one vertex.
                    // Check its two lifted endpoints in model space against that source vertex.
                    var currentLift = Evaluate(surface, currentUv);
                    var nextLift = Evaluate(surface, nextUv);
                    var vertex = coedge.IsReversed ? edge.StartVertexId : edge.EndVertexId;
                    var sourceLimit = sourceTopology.VertexTolerancesMillimetres.GetValueOrDefault(vertex);
                    if (currentLift is null || nextLift is null || !body.TryGetVertexPoint(vertex, out var vertexPoint)
                        || (currentLift.Value - vertexPoint).Length > double.Max(closureTolerance, sourceLimit)
                        || (nextLift.Value - vertexPoint).Length > double.Max(closureTolerance, sourceLimit))
                    {
                        loopClosureValid = false;
                        diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:collapsed-singular-lift");
                    }
                }
                else if (closure > closureTolerance && !MeetAtSingularPoint(surface, currentUv, nextUv, closureTolerance)
                         && !(sharedVertexTolerance > 0d && Evaluate(surface, currentUv) is { } liftA && Evaluate(surface, nextUv) is { } liftB
                              && (liftA - liftB).Length <= 2d * sharedVertexTolerance + closureTolerance))
                {
                    loopClosureValid = false;
                    diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:uv-loop-closure={closure:R}:tolerance={closureTolerance:R}");
                }
            }
        }

        var count = body.Bindings.PcurveBindings.Count();
        var valid = diagnostics.Count == 0 && domainValid && orientationValid && loopClosureValid;
        return new(valid, body.Topology.Edges.Count(), count, maximum, domainValid, orientationValid, diagnostics)
        {
            LoopClosureValid = loopClosureValid,
            MaximumUvLoopClosure = maximumUvClosure,
            RootMeanSquareReconstructionDeviation = residualSamples == 0 ? 0d : double.Sqrt(squaredResidual / residualSamples)
        };
    }

    /// <summary>A sphere pole or cone apex is one model point for every U: two pcurves can meet there
    /// with any U gap. Accept when both ends lift to the same point and U is degenerate at it.</summary>
    private static bool MeetAtSingularPoint(SurfaceGeometry surface, SurfaceParameterPoint a, SurfaceParameterPoint b, double tolerance)
    {
        if (Evaluate(surface, a) is not { } pa || Evaluate(surface, b) is not { } pb || (pa - pb).Length > tolerance) return false;
        bool Degenerate(SurfaceParameterPoint uv, Point3D p)
            => Evaluate(surface, new SurfaceParameterPoint(uv.U + 1e-3, uv.V)) is { } q && (q - p).Length <= tolerance;
        return Degenerate(a, pa) && Degenerate(b, pb);
    }

    private static bool WithinSurfaceDomain(SurfaceGeometry surface, SurfaceParameterPoint uv, double tolerance)
    {
        if (!double.IsFinite(uv.U) || !double.IsFinite(uv.V)) return false;
        if (surface.BSplineSurfaceWithKnots is not { } spline) return true;
        return uv.U >= spline.DomainStartU - tolerance && uv.U <= spline.DomainEndU + tolerance
            && uv.V >= spline.DomainStartV - tolerance && uv.V <= spline.DomainEndV + tolerance;
    }

    private static double UvDistance(SurfaceGeometry surface, SurfaceParameterPoint a, SurfaceParameterPoint b)
    {
        // Distinct generator angles meet at one exact cone apex. Comparing U
        // there rejects a closed boundary solely because its chart is singular.
        if (surface.Cone is not null && double.Abs(a.V) <= 1e-10 && double.Abs(b.V) <= 1e-10)
            return double.Abs(a.V - b.V);
        var periodicity = SurfacePeriodicity.Of(surface);
        var du = PeriodicDelta(a.U - b.U, periodicity.UPeriod);
        var dv = PeriodicDelta(a.V - b.V, periodicity.VPeriod);
        return double.Sqrt((du * du) + (dv * dv));
    }

    private static double PeriodicDelta(double delta, double? period)
        => period is double value && value > 0d && double.IsFinite(value)
            ? delta - double.Round(delta / value) * value
            : delta;

    private static bool FiniteOrdered(ParameterInterval interval) => double.IsFinite(interval.Start) && double.IsFinite(interval.End) && interval.End >= interval.Start;

    private static Point3D? Evaluate(SurfaceGeometry surface, SurfaceParameterPoint uv) => surface.Kind switch
    {
        SurfaceGeometryKind.Plane => surface.Plane!.Value.Evaluate(uv.U, uv.V),
        SurfaceGeometryKind.Cylinder => surface.Cylinder!.Value.Evaluate(uv.U, uv.V),
        SurfaceGeometryKind.Cone => surface.Cone!.Value.Evaluate(uv.U, uv.V),
        SurfaceGeometryKind.Sphere => surface.Sphere!.Value.Evaluate(uv.U, uv.V),
        SurfaceGeometryKind.Torus => surface.Torus!.Value.Evaluate(uv.U, uv.V),
        SurfaceGeometryKind.Ellipsoid => surface.Ellipsoid!.Evaluate(uv.U, uv.V),
        SurfaceGeometryKind.BSplineSurfaceWithKnots => surface.BSplineSurfaceWithKnots!.Evaluate(uv.U, uv.V),
        _ => null
    };

    internal static Point3D? Evaluate(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),
        CurveGeometryKind.Ellipse3 => curve.Ellipse3!.Value.Evaluate(parameter),
        CurveGeometryKind.Hyperbola3 => curve.Hyperbola3!.Value.Evaluate(parameter),
        _ => null
    };
}