Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

4.0 KB
Raw Blame
using Aetheris.Kernel.Core.Diagnostics;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Numerics;
using Aetheris.Kernel.Core.Results;

namespace Aetheris.Kernel.Core.Geometry.Curves;

/// <summary>A finite polynomial curve subordinate to one exact helical rib boundary.</summary>
public sealed record QualifiedHelicalRibBoundary(
    CylindricalHelix3 Authority,
    BSpline3Curve Curve,
    double RequestedToleranceMm,
    double AnalyticErrorBoundMm,
    double NumericalAllowanceMm,
    int SegmentCount)
{
    public double CertifiedDeviationBoundMm => AnalyticErrorBoundMm + NumericalAllowanceMm;
}

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

    public static KernelResult<QualifiedHelicalRibBoundary> Realize(
        CylindricalHelix3 authority, ToleranceContext? tolerance = null)
    {
        var requested = (tolerance ?? ToleranceContext.Default).Linear;
        var axialEnd = authority.AxialStartMm + authority.PitchMm * authority.Turns;
        var scale = double.Max(1d, double.Max(authority.RadiusMm,
            double.Max(double.Max(double.Abs(authority.AxialStartMm), double.Abs(axialEnd)),
                double.Max(double.Abs(authority.AxisOrigin.X),
                    double.Max(double.Abs(authority.AxisOrigin.Y), double.Abs(authority.AxisOrigin.Z))))));
        var allowance = 256d * MachineEpsilon * scale;
        var budget = requested - allowance;
        if (budget <= 0d)
            return Failure("numeric-tolerance", "Coordinate scale consumes the requested tolerance.");

        // Cubic Hermite remainder: |f''''| h^4 / 384. The axial coordinate is
        // linear in angle; the fourth derivative is purely radial with norm r.
        var maximumSpan = double.Pow(384d * budget / authority.RadiusMm, 0.25d);
        var angleRange = authority.EndAngleRadians - authority.StartAngleRadians;
        var segmentCountReal = double.Ceiling(angleRange / maximumSpan);
        if (!double.IsFinite(segmentCountReal) || segmentCountReal < 1d || segmentCountReal > MaxSegments)
            return Failure("segment-budget", "Certified helix realization exceeds the bounded segment budget.");
        var segmentCount = (int)segmentCountReal;
        var h = angleRange / segmentCount;
        var error = authority.RadiusMm * double.Pow(h, 4d) / 384d;
        var controls = new List<Point3D>(3 * segmentCount + 1);
        var knots = new List<double>(segmentCount + 1);
        var multiplicities = new List<int>(segmentCount + 1);
        knots.Add(authority.StartAngleRadians);
        multiplicities.Add(4);
        for (var i = 0; i < segmentCount; i++)
        {
            var a = authority.StartAngleRadians + angleRange * i / segmentCount;
            var b = i == segmentCount - 1 ? authority.EndAngleRadians
                : authority.StartAngleRadians + angleRange * (i + 1) / segmentCount;
            var width = b - a;
            var p0 = authority.Evaluate(a);
            var p3 = authority.Evaluate(b);
            if (i == 0) controls.Add(p0);
            controls.Add(p0 + authority.Derivative(a) * (width / 3d));
            controls.Add(p3 - authority.Derivative(b) * (width / 3d));
            controls.Add(p3);
            knots.Add(b);
            multiplicities.Add(i == segmentCount - 1 ? 4 : 3);
        }
        var curve = new BSpline3Curve(3, controls, multiplicities, knots,
            "UNSPECIFIED", false, false, "UNSPECIFIED");
        return KernelResult<QualifiedHelicalRibBoundary>.Success(new(
            authority, curve, requested, error, allowance, segmentCount));
    }

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