Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

7.6 KB
Raw Blame
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Geometry.Curves;
using Aetheris.Kernel.Core.Geometry.Surfaces;
using Aetheris.Kernel.Core.Math;

namespace Aetheris.Kernel.Core.Tests.Geometry;

public sealed class HelicalRibGeometryTests
{
    private static readonly Direction3D Z = Direction3D.Create(new Vector3D(0, 0, 1));
    private static readonly Direction3D X = Direction3D.Create(new Vector3D(1, 0, 0));

    private static HelicalRibParameters Witness(double span = 30d, double pitch = 1.25d,
        double crestRadius = 4d, double rootWidth = 1.1d) => new(
        Point3D.Origin, Z, X, 0d, span + rootWidth,
        3.2d, crestRadius, pitch, rootWidth / 2d,
        span + rootWidth / 2d, rootWidth, 0.1d);

    [Fact]
    public void OneAndManyTurnsHaveExactFrameProfileAndDerivedLead()
    {
        foreach (var span in new[] { 1.25d, 30d })
        {
            var result = HelicalRibGeometry.Create(Witness(span));
            Assert.True(result.IsSuccess, string.Join("; ", result.Diagnostics));
            var rib = result.Value;
            Assert.Equal(span / 1.25d, rib.Turns, 12);
            Assert.Equal(1.25d, rib.LeadMm);
            Assert.Equal(0.15d, rib.MinimumAdjacentTurnClearanceMm, 12);

            foreach (var role in Enum.GetValues<HelicalRibBoundaryRole>())
            {
                var helix = rib.Boundary(role);
                var first = helix.Evaluate(helix.StartAngleRadians);
                var last = helix.Evaluate(helix.EndAngleRadians);
                Assert.Equal(span, last.Z - first.Z, 10);
                Assert.Equal(helix.RadiusMm, double.Hypot(first.X, first.Y), 10);
                Assert.Equal(helix.RadiusMm, double.Hypot(last.X, last.Y), 10);
            }
            var mid = rib.Parameters.StartAngleRadians + (rib.EndAngleRadians - rib.Parameters.StartAngleRadians) * 0.37d;
            Assert.Equal(rib.Boundary(HelicalRibBoundaryRole.LeadingCrest).Evaluate(mid),
                rib.Evaluate(HelicalRibSideRole.Crest, mid, 0d));
            Assert.Equal(rib.Boundary(HelicalRibBoundaryRole.TrailingCrest).Evaluate(mid),
                rib.Evaluate(HelicalRibSideRole.Crest, mid, 1d));
            Assert.Equal(4, rib.CapCorners(false).Count);
        }
    }

    [Fact]
    public void PitchLengthDepthAndRigidFrameChangeGeometryDeterministically()
    {
        var original = HelicalRibGeometry.Create(Witness()).Value;
        var faster = HelicalRibGeometry.Create(Witness(pitch: 1.5d)).Value;
        var longer = HelicalRibGeometry.Create(Witness(span: 35d)).Value;
        var deeper = HelicalRibGeometry.Create(Witness(crestRadius: 4.2d)).Value;
        Assert.Equal(24d, original.Turns);
        Assert.Equal(20d, faster.Turns);
        Assert.Equal(28d, longer.Turns);
        Assert.Equal(4.2d, deeper.Boundary(HelicalRibBoundaryRole.LeadingCrest).RadiusMm);
        Assert.Equal(3.2d, deeper.Boundary(HelicalRibBoundaryRole.LeadingRoot).RadiusMm);

        var transformed = Witness() with {
            AxisOrigin = new Point3D(7d, -4d, 2d),
            Axis = Direction3D.Create(new Vector3D(1d, 0d, 0d)),
            StartRadial = Direction3D.Create(new Vector3D(0d, 1d, 0d))
        };
        var rotated = HelicalRibGeometry.Create(transformed).Value;
        var p = rotated.Boundary(HelicalRibBoundaryRole.LeadingRoot).Evaluate(rotated.Parameters.StartAngleRadians);
        Assert.Equal(7d + transformed.AxialStartMm - transformed.RootWidthMm / 2d, p.X, 10);
        Assert.Equal(-4d + 3.2d, p.Y, 10);
        Assert.Equal(2d, p.Z, 10);
    }

    [Theory]
    [InlineData(0d, 30d, 1.1d, "pitch")]
    [InlineData(-1d, 30d, 1.1d, "pitch")]
    [InlineData(1.25d, 0d, 1.1d, "span")]
    [InlineData(1.25d, 30d, 1.25d, "adjacent-turn-overlap")]
    public void InvalidIntentHasSpecificDiagnostic(double pitch, double span, double rootWidth, string code)
    {
        var p = Witness(span, pitch, rootWidth: rootWidth);
        var result = HelicalRibGeometry.Create(p);
        Assert.False(result.IsSuccess);
        Assert.Contains(result.Diagnostics, d => d.Message.Contains($"helical-rib-{code}", StringComparison.Ordinal));
    }

    [Fact]
    public void OutOfSupportAndInvertedDepthAreRejected()
    {
        var outside = HelicalRibGeometry.Create(Witness() with { SupportAxialMaxMm = 30d });
        var inverted = HelicalRibGeometry.Create(Witness(crestRadius: 3.2d));
        Assert.Contains(outside.Diagnostics, d => d.Message.Contains("support-extent", StringComparison.Ordinal));
        Assert.Contains(inverted.Diagnostics, d => d.Message.Contains("radii", StringComparison.Ordinal));
    }

    [Fact]
    public void PeriodicAngularWrapPreservesRadialPositionAndAdvancesOnePitch()
    {
        var rib = HelicalRibGeometry.Create(Witness()).Value;
        var helix = rib.Boundary(HelicalRibBoundaryRole.TrailingCrest);
        var first = helix.Evaluate(helix.StartAngleRadians);
        var next = helix.Evaluate(helix.StartAngleRadians + 2d * double.Pi);
        Assert.InRange(double.Abs(first.X - next.X), 0d, 1e-12d);
        Assert.InRange(double.Abs(first.Y - next.Y), 0d, 1e-12d);
        Assert.Equal(1.25d, next.Z - first.Z, 10);
    }

    [Fact]
    public void NonRationalBoundaryRealizationIsCertifiedAndRepeatable()
    {
        var rib = HelicalRibGeometry.Create(Witness()).Value;
        var helix = rib.Boundary(HelicalRibBoundaryRole.LeadingCrest);
        var first = HelicalRibBoundaryRealizer.Realize(helix);
        var second = HelicalRibBoundaryRealizer.Realize(helix);
        Assert.True(first.IsSuccess, string.Join("; ", first.Diagnostics));
        Assert.True(second.IsSuccess);
        Assert.InRange(first.Value.CertifiedDeviationBoundMm, 0d, 1e-6d);
        Assert.Equal(first.Value.Curve.ControlPoints, second.Value.Curve.ControlPoints);
        Assert.True(first.Value.SegmentCount > 20);
        for (var i = 0; i <= 80; i++)
        {
            var angle = helix.StartAngleRadians + (helix.EndAngleRadians - helix.StartAngleRadians) * i / 80d;
            var deviation = (first.Value.Curve.Evaluate(angle) - helix.Evaluate(angle)).Length;
            Assert.InRange(deviation, 0d, first.Value.CertifiedDeviationBoundMm);
        }
    }

    [Theory]
    [InlineData(false)]
    [InlineData(true)]
    public void AllThreeRuledHelicalSidesRemainWithinCertifiedSurfaceBound(bool inward)
    {
        var p = Witness();
        if (inward) p = p with { RootRadiusMm = p.CrestRadiusMm, CrestRadiusMm = p.RootRadiusMm, Intent = HelicalProfileIntent.RemoveGroove };
        var rib = HelicalRibGeometry.Create(p).Value;
        foreach (var role in Enum.GetValues<HelicalRibSideRole>())
        {
            var realized = HelicalRibSurfaceRealizer.Realize(rib, role);
            Assert.True(realized.IsSuccess, string.Join("; ", realized.Diagnostics));
            Assert.InRange(realized.Value.CertifiedDeviationBoundMm, 0d, 1e-6d);
            Assert.False(realized.Value.Surface.IsRational);
            Assert.Equal(3 * realized.Value.SegmentCount + 1, realized.Value.Surface.ControlPoints.Count);
            Assert.All(realized.Value.Surface.KnotMultiplicitiesU.Skip(1).SkipLast(1), multiplicity => Assert.Equal(3, multiplicity));
            for (var i = 0; i <= 40; i++)
            {
                var angle = rib.Parameters.StartAngleRadians
                    + (rib.EndAngleRadians - rib.Parameters.StartAngleRadians) * i / 40d;
                foreach (var v in new[] { 0d, 0.3d, 1d })
                {
                    var error = (realized.Value.Surface.Evaluate(angle, v) - rib.Evaluate(role, angle, v)).Length;
                    Assert.InRange(error, 0d, realized.Value.CertifiedDeviationBoundMm);
                }
            }
        }
    }
}