Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

13.8 KB
Raw Blame
using Aetheris.Kernel.Core.Air;
using Aetheris.Kernel.Core.Geometry.Curves;

namespace Aetheris.Kernel.Firmament.Materializer;

/// <summary>
/// Exact, non-tessellated host evidence for a construction-plane shaft through
/// the normalized section stack.  A partition is a planning boundary; a span is
/// material only after adjacent partitions have been proven continuous.
/// </summary>
public enum SectionStackFootprintClassification { InsideMaterial, Tangent, CrossesOuterBoundary, IntersectsInnerVoid, OutsideMaterial, Ambiguous }

public sealed record SectionStackHoleFootprintCheck(
    double LocalAxisStart, double LocalAxisEnd, double CenterX, double CenterY,
    double Radius, SectionStackFootprintClassification Classification, double NearestBoundaryDistance,
    IReadOnlyList<string> BoundaryProvenance);

public sealed record SectionStackHolePlannerPartition(
    double LocalAxisStart, double LocalAxisEnd, double SectionFrom, double SectionTo,
    IReadOnlyList<string> ActiveOperations, IReadOnlyList<string> ProfileRegions,
    bool CompleteCircularFootprintInMaterial, string EntryEvent, string ExitEvent,
    SectionStackHoleFootprintCheck Footprint, IReadOnlyList<string> Provenance)
{
    public double Length => LocalAxisEnd - LocalAxisStart;
}

public sealed record SectionStackHolePhysicalSpan(double Start, double End, IReadOnlyList<int> PartitionIndices, bool IsContinuous)
{
    public double Length => End - Start;
}

public sealed record SectionStackHoleTraversalEvidence(
    HoleHostTraversalEvidence HostTraversal,
    IReadOnlyList<SectionStackHolePlannerPartition> OrderedPartitions,
    IReadOnlyList<SectionStackHolePhysicalSpan> PhysicalSpans,
    IReadOnlyList<string> TransitionEvents,
    IReadOnlyList<SectionStackHoleFootprintCheck> FootprintChecks,
    IReadOnlyList<string> Diagnostics,
    IReadOnlyList<string> Provenance);

/// <summary>
/// Traverses the already-normalized stack.  The initial admitted mapping is an
/// axial signed-permutation plane (+/- world Z): this is the only mapping whose
/// circular footprint is a disk in the stack's native XY section.  Transverse
/// planes deliberately reject here rather than reusing the Box interval or
/// silently treating a YZ/XZ footprint as an XY disk.
/// </summary>
internal static class PrismaticSectionStackHoleTraversal
{
    private const double Tol = 1e-8;

    public static SectionStackHoleTraversalEvidence Traverse(
        AirHoleFeature feature, PrismaticSectionStackConstruction stack, AirConstructionPlaneHolePlacement placement)
    {
        var diagnostics = new List<string>();
        var axis = placement.AxisZ.ToVector();
        var mouth = placement.WorldMouthCenter;
        if (!IsSignedPermutation(placement))
            diagnostics.Add("SectionStackHoleOrientationUnsupported: Construction Plane must be a signed-permutation frame.");
        if (Math.Abs(axis.Z) < 1d - Tol)
            diagnostics.Add("SectionStackHoleTransverseTraversalNotYetAdmitted: a transverse shaft footprint is YZ/XZ, not the stack native XY disk; no Box-interval fallback is permitted.");

        if (diagnostics.Count > 0)
            return Empty(feature, stack, placement, diagnostics);

        // t is always construction-plane local +Z distance.  For +/-Z axes the
        // section centre is invariant in XY and the radius test is exact against
        // every admitted line/arc boundary of the active normalized region.
        var raw = new List<(PrismaticSectionSlab Slab, double Start, double End)>();
        foreach (var slab in stack.Slabs)
        {
            var a = (slab.From - mouth.Z) / axis.Z;
            var b = (slab.To - mouth.Z) / axis.Z;
            var start = Math.Max(0d, Math.Min(a, b)); var end = Math.Max(a, b);
            if (end - start > Tol) raw.Add((slab, start, end));
        }
        raw.Sort((x, y) => x.Start.CompareTo(y.Start));
        if (raw.Count == 0)
        {
            diagnostics.Add("MouthMissesHost: construction-plane mouth does not meet any section-stack material slab.");
            return Empty(feature, stack, placement, diagnostics);
        }

        // Do not turn a clipped first interval into a mouth event: it would hide
        // an author declaring a mouth inside existing material.
        var firstRawStart = raw[0].Start;
        var firstUnclipped = axis.Z > 0d
            ? (raw[0].Slab.From - mouth.Z) / axis.Z
            : (raw[0].Slab.To - mouth.Z) / axis.Z;
        if (firstUnclipped < -Tol) diagnostics.Add("MouthInsideHostUnexpectedly: construction-plane mouth is inside material, not on its entering boundary.");
        if (firstRawStart > Tol) diagnostics.Add("DirectionDoesNotEnterMaterial: local +Z reaches air before host material.");

        var partitions = new List<SectionStackHolePlannerPartition>();
        foreach (var item in raw)
        {
            var check = CheckDisk(item.Slab.Region, (mouth.X, mouth.Y), feature.Shaft.Radius, item.Start, item.End);
            var footprintSupported = check.Classification == SectionStackFootprintClassification.InsideMaterial;
            if (!footprintSupported) diagnostics.Add($"HoleFootprintLeavesHost: slab=[{item.Slab.From:R},{item.Slab.To:R}]; classification={check.Classification}.");
            var index = partitions.Count;
            partitions.Add(new(item.Start, item.End, item.Slab.From, item.Slab.To, item.Slab.ActiveOperations,
                item.Slab.Region.Provenance, footprintSupported,
                index == 0 ? "MouthCandidate" : "PlannerTransition",
                "PlannerTransitionOrHostBoundary", check,
                item.Slab.Region.Provenance.Concat(["PrismaticSectionStackConstruction", "ProfileArrangement2D"]).Distinct().ToArray()));
        }

        var transitions = new List<string>();
        for (var i = 1; i < partitions.Count; i++)
        {
            var previous = partitions[i - 1]; var current = partitions[i];
            var continuous = Math.Abs(previous.LocalAxisEnd - current.LocalAxisStart) <= Tol &&
                previous.CompleteCircularFootprintInMaterial && current.CompleteCircularFootprintInMaterial;
            transitions.Add($"localAxis={current.LocalAxisStart:R}; kind={(continuous ? "InternalPlannerPartition" : "HostBoundaryOrVoid")}; below=[{previous.SectionFrom:R},{previous.SectionTo:R}]; above=[{current.SectionFrom:R},{current.SectionTo:R}]");
        }

        var spans = Collapse(partitions);
        var supported = partitions.Where(x => x.CompleteCircularFootprintInMaterial).ToArray();
        HoleHostTraversalClassification classification = supported.Length switch
        {
            0 => partitions.Any(x => x.Footprint.Classification == SectionStackFootprintClassification.Tangent) ? HoleHostTraversalClassification.TangentialContact : HoleHostTraversalClassification.NoMaterial,
            _ when spans.Count == 1 && partitions.Count == 1 => HoleHostTraversalClassification.OneContiguousInterval,
            _ when spans.Count == 1 => HoleHostTraversalClassification.MultipleContiguousPartitionsOfOneMaterialSpan,
            _ => HoleHostTraversalClassification.DisconnectedMaterialIntervals
        };
        var intervals = partitions.Select((p, i) => new HoleHostMaterialIntervalEvidence(p.LocalAxisStart, p.LocalAxisEnd,
            $"section-stack:slab:{p.SectionFrom:R}..{p.SectionTo:R}:partition:{i}", string.Join(";", p.Provenance),
            p.CompleteCircularFootprintInMaterial, p.EntryEvent, p.ExitEvent)).ToArray();
        var host = new HoleHostTraversalEvidence(feature.FeatureId, feature.TargetBodyId ?? stack.Feature.Name, placement.ConstructionPlaneId,
            [mouth.X, mouth.Y, mouth.Z], [axis.X, axis.Y, axis.Z], feature.Shaft.Radius, classification, intervals, diagnostics.Distinct().ToArray());
        return new(host, partitions, spans, transitions, partitions.Select(x => x.Footprint).ToArray(), diagnostics.Distinct().ToArray(),
            ["PrismaticSectionStackConstruction", "ProfileArrangement2D", "ExactLineArcDiskContainment", "NoTessellation"]);
    }

    private static SectionStackHoleTraversalEvidence Empty(AirHoleFeature feature, PrismaticSectionStackConstruction stack, AirConstructionPlaneHolePlacement placement, IReadOnlyList<string> diagnostics)
    {
        var mouth = placement.WorldMouthCenter; var axis = placement.AxisZ.ToVector();
        var host = new HoleHostTraversalEvidence(feature.FeatureId, feature.TargetBodyId ?? stack.Feature.Name, placement.ConstructionPlaneId,
            [mouth.X, mouth.Y, mouth.Z], [axis.X, axis.Y, axis.Z], feature.Shaft.Radius, HoleHostTraversalClassification.NoMaterial, [], diagnostics);
        return new(host, [], [], [], [], diagnostics, ["PrismaticSectionStackConstruction", "NoBoxIntervalFallback"]);
    }

    private static IReadOnlyList<SectionStackHolePhysicalSpan> Collapse(IReadOnlyList<SectionStackHolePlannerPartition> partitions)
    {
        var result = new List<SectionStackHolePhysicalSpan>();
        var current = new List<int>();
        for (var i = 0; i < partitions.Count; i++)
        {
            var partition = partitions[i];
            var contiguous = current.Count > 0 && Math.Abs(partitions[current[^1]].LocalAxisEnd - partition.LocalAxisStart) <= Tol;
            if (!partition.CompleteCircularFootprintInMaterial || (!contiguous && current.Count > 0))
            {
                if (current.Count > 0) result.Add(new(partitions[current[0]].LocalAxisStart, partitions[current[^1]].LocalAxisEnd, current.ToArray(), true));
                current.Clear();
            }
            if (partition.CompleteCircularFootprintInMaterial) current.Add(i);
        }
        if (current.Count > 0) result.Add(new(partitions[current[0]].LocalAxisStart, partitions[current[^1]].LocalAxisEnd, current.ToArray(), true));
        return result;
    }

    internal static SectionStackHoleFootprintCheck CheckDisk(PrismaticSectionRegion region, (double X, double Y) center, double radius, double start, double end)
    {
        var outerLocation = ProfileArrangementBuilder.PointInProfile(region.Outer, center);
        var outer = BoundaryDistance(region.Outer, center);
        var holes = region.Holes.Select(h => (Location: ProfileArrangementBuilder.PointInProfile(h, center), Distance: BoundaryDistance(h, center), Profile: h)).ToArray();
        var provenance = region.Provenance;
        if (!double.IsFinite(outer) || holes.Any(h => !double.IsFinite(h.Distance)))
            return new(start, end, center.X, center.Y, radius, SectionStackFootprintClassification.Ambiguous, double.NaN,
                provenance.Append("ExactDiskBoundaryUnsupported:requires-line-or-circular-arc").ToArray());
        if (outerLocation != ArrangementPointLocation.Inside)
            return new(start, end, center.X, center.Y, radius, SectionStackFootprintClassification.OutsideMaterial, outer, provenance);
        if (holes.Any(x => x.Location is ArrangementPointLocation.Inside or ArrangementPointLocation.OnBoundary))
            return new(start, end, center.X, center.Y, radius, SectionStackFootprintClassification.IntersectsInnerVoid, holes.Min(x => x.Distance), provenance);
        var nearest = Math.Min(outer, holes.Length == 0 ? double.PositiveInfinity : holes.Min(x => x.Distance));
        var kind = Math.Abs(nearest - radius) <= Tol ? SectionStackFootprintClassification.Tangent
            : nearest < radius ? (outer < radius ? SectionStackFootprintClassification.CrossesOuterBoundary : SectionStackFootprintClassification.IntersectsInnerVoid)
            : SectionStackFootprintClassification.InsideMaterial;
        return new(start, end, center.X, center.Y, radius, kind, nearest, provenance);
    }

    private static double BoundaryDistance(ResolvedProfile2D profile, (double X, double Y) point) => profile.Loops.Single().Segments.Min(segment => segment.Geometry switch
    {
        LineArcLineSegment2D line => DistanceToLineSegment(point, line.Start, line.End),
        LineArcCircularArc2D arc => DistanceToArc(point, arc),
        _ => double.NaN
    });

    private static double DistanceToLineSegment((double X, double Y) p, (double X, double Y) a, (double X, double Y) b)
    {
        var dx = b.X - a.X; var dy = b.Y - a.Y; var length2 = dx * dx + dy * dy;
        var t = Math.Clamp(((p.X - a.X) * dx + (p.Y - a.Y) * dy) / length2, 0d, 1d);
        return Math.Sqrt(Math.Pow(p.X - (a.X + t * dx), 2) + Math.Pow(p.Y - (a.Y + t * dy), 2));
    }

    private static double DistanceToArc((double X, double Y) p, LineArcCircularArc2D arc)
    {
        var dx = p.X - arc.Center.X; var dy = p.Y - arc.Center.Y; var distance = Math.Sqrt(dx * dx + dy * dy);
        var angle = Math.Atan2(dy, dx);
        if (OnArc(arc, angle)) return Math.Abs(distance - arc.Radius);
        var a = (arc.Center.X + arc.Radius * Math.Cos(arc.StartAngleRadians), arc.Center.Y + arc.Radius * Math.Sin(arc.StartAngleRadians));
        var bAngle = arc.StartAngleRadians + arc.SweepAngleRadians;
        var b = (arc.Center.X + arc.Radius * Math.Cos(bAngle), arc.Center.Y + arc.Radius * Math.Sin(bAngle));
        return Math.Min(Math.Sqrt(Math.Pow(p.X - a.Item1, 2) + Math.Pow(p.Y - a.Item2, 2)), Math.Sqrt(Math.Pow(p.X - b.Item1, 2) + Math.Pow(p.Y - b.Item2, 2)));
    }

    private static bool OnArc(LineArcCircularArc2D arc, double angle)
    {
        var delta = angle - arc.StartAngleRadians;
        if (arc.SweepAngleRadians >= 0d) while (delta < 0d) delta += 2d * Math.PI;
        else while (delta > 0d) delta -= 2d * Math.PI;
        return delta / arc.SweepAngleRadians >= -Tol && delta / arc.SweepAngleRadians <= 1d + Tol;
    }

    private static bool IsSignedPermutation(AirConstructionPlaneHolePlacement placement)
    {
        var axes = new[] { placement.AxisX.ToVector(), placement.AxisY.ToVector(), placement.AxisZ.ToVector() };
        return axes.All(axis => new[] { Math.Abs(axis.X), Math.Abs(axis.Y), Math.Abs(axis.Z) }.Count(value => Math.Abs(value - 1d) <= Tol) == 1
            && new[] { Math.Abs(axis.X), Math.Abs(axis.Y), Math.Abs(axis.Z) }.Count(value => value <= Tol) == 2);
    }
}