Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

4.9 KB
Raw Blame
using Aetheris.Kernel.Core.Diagnostics;
using Aetheris.Kernel.Core.Geometry.Curves;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Numerics;
using Aetheris.Kernel.Core.Results;

namespace Aetheris.Kernel.Core.Geometry.Surfaces;

/// <summary>Finite flank/crest surface subordinate to an exact constant-profile helical rib.</summary>
public sealed record QualifiedHelicalRibSurface(
    HelicalRibGeometry Authority,
    HelicalRibSideRole Role,
    BSplineSurfaceWithKnots Surface,
    double RequestedToleranceMm,
    double AnalyticErrorBoundMm,
    double NumericalAllowanceMm,
    int SegmentCount)
{
    public double CertifiedDeviationBoundMm => AnalyticErrorBoundMm + NumericalAllowanceMm;
}

public static class HelicalRibSurfaceRealizer
{
    private const int MaxSegments = 16_384;
    private const double MachineEpsilon = 2.2204460492503131e-16d;

    public static KernelResult<QualifiedHelicalRibSurface> Realize(
        HelicalRibGeometry rib, HelicalRibSideRole role, ToleranceContext? tolerance = null)
    {
        ArgumentNullException.ThrowIfNull(rib);
        var (firstRole, secondRole) = role switch
        {
            HelicalRibSideRole.LeadingFlank => (HelicalRibBoundaryRole.LeadingRoot, HelicalRibBoundaryRole.LeadingCrest),
            HelicalRibSideRole.Crest => (HelicalRibBoundaryRole.LeadingCrest, HelicalRibBoundaryRole.TrailingCrest),
            HelicalRibSideRole.TrailingFlank => (HelicalRibBoundaryRole.TrailingCrest, HelicalRibBoundaryRole.TrailingRoot),
            _ => throw new ArgumentOutOfRangeException(nameof(role))
        };
        var first = rib.Boundary(firstRole);
        var second = rib.Boundary(secondRole);
        var requested = (tolerance ?? ToleranceContext.Default).Linear;
        var p = rib.Parameters;
        var scale = double.Max(1d, double.Max(double.Max(p.CrestRadiusMm, p.RootRadiusMm),
            double.Max(double.Abs(p.SupportAxialMinMm),
                double.Max(double.Abs(p.SupportAxialMaxMm),
                    double.Max(double.Abs(p.AxisOrigin.X),
                        double.Max(double.Abs(p.AxisOrigin.Y), double.Abs(p.AxisOrigin.Z)))))));
        var allowance = 256d * MachineEpsilon * scale;
        var budget = requested - allowance;
        if (budget <= 0d)
            return Failure("numeric-tolerance", "Coordinate scale consumes the requested tolerance.");
        var maximumRadius = double.Max(first.RadiusMm, second.RadiusMm);
        // The surface is linear in profile coordinate v. Hermite interpolation
        // in angle has fourth derivative norm <= max endpoint radius.
        var maximumSpan = double.Pow(384d * budget / maximumRadius, 0.25d);
        var angleRange = rib.EndAngleRadians - p.StartAngleRadians;
        var countReal = double.Ceiling(angleRange / maximumSpan);
        if (!double.IsFinite(countReal) || countReal < 1d || countReal > MaxSegments)
            return Failure("segment-budget", "Certified helical surface exceeds the bounded segment budget.");
        var count = (int)countReal;
        var h = angleRange / count;
        var analyticError = maximumRadius * double.Pow(h, 4d) / 384d;
        var rows = new List<IReadOnlyList<Point3D>>(count * 3 + 1);
        var knots = new List<double>(count + 1) { p.StartAngleRadians };
        var multiplicities = new List<int>(count + 1) { 4 };
        for (var i = 0; i < count; i++)
        {
            var a = p.StartAngleRadians + angleRange * i / count;
            var b = i == count - 1 ? rib.EndAngleRadians : p.StartAngleRadians + angleRange * (i + 1) / count;
            var width = b - a;
            var a0 = first.Evaluate(a);
            var b0 = first.Evaluate(b);
            var a1 = second.Evaluate(a);
            var b1 = second.Evaluate(b);
            // Adjacent Hermite spans share their endpoint. Interior multiplicity
            // is degree (C0), not degree+1, which external CAD kernels reject.
            if (i == 0) rows.Add([a0, a1]);
            rows.Add([a0 + first.Derivative(a) * (width / 3d),
                a1 + second.Derivative(a) * (width / 3d)]);
            rows.Add([b0 - first.Derivative(b) * (width / 3d),
                b1 - second.Derivative(b) * (width / 3d)]);
            rows.Add([b0, b1]);
            knots.Add(b);
            multiplicities.Add(i == count - 1 ? 4 : 3);
        }
        var surface = new BSplineSurfaceWithKnots(3, 1, rows,
            "UNSPECIFIED", false, false, false,
            multiplicities, [2, 2], knots, [0d, 1d], "UNSPECIFIED");
        return KernelResult<QualifiedHelicalRibSurface>.Success(new(
            rib, role, surface, requested, analyticError, allowance, count));
    }

    private static KernelResult<QualifiedHelicalRibSurface> Failure(string code, string message) =>
        KernelResult<QualifiedHelicalRibSurface>.Failure([
            new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error,
                $"helical-rib-surface-{code}: {message}", "Geometry.HelicalRib.Surface")]);
}