Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

11.6 KB
Raw Blame
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Geometry.Surfaces;
using Aetheris.Kernel.Core.Math;
using System.Text.Json;
using System.Text.Json.Serialization;

namespace Aetheris.Surfacing;

public readonly record struct SurfaceParameterDomain(double UMin, double UMax, double VMin, double VMax)
{
    public bool IsValid => double.IsFinite(UMin) && double.IsFinite(UMax) && double.IsFinite(VMin) && double.IsFinite(VMax)
        && UMin < UMax && VMin < VMax;
}

public enum SurfacePatchClass { Analytic, NonRationalBSpline, InternalRationalNormalized }
public enum PatchBoundarySide { South, East, North, West }
public enum PatchBoundaryContinuity { G0, G1, G2 }

public sealed record PatchBoundaryCorrespondence(
    string StableId,
    PatchBoundarySide PatchSide,
    string ExistingBoundary,
    PatchBoundaryContinuity Continuity);

public sealed record SurfaceBoundaryLoop(
    string StableId,
    IReadOnlyList<PatchBoundaryCorrespondence> Boundaries,
    bool IsOuter = true)
{
    public IReadOnlyList<SculptDiagnostic> Validate()
    {
        var diagnostics = new List<SculptDiagnostic>();
        if (!IsOuter) diagnostics.Add(new("surf-boundary-inner-loop-unsupported", "SURF-X1 currently supports one outer replacement loop and no holes in the replacement patch."));
        if (Boundaries.Count != 4 || Boundaries.Select(x => x.PatchSide).Distinct().Count() != 4)
            diagnostics.Add(new("surf-boundary-loop-invalid", "A rectangular replacement loop requires exactly one correspondence for South, East, North, and West."));
        if (Boundaries.Any(x => string.IsNullOrWhiteSpace(x.ExistingBoundary)))
            diagnostics.Add(new("surf-boundary-correspondence-invalid", "Every patch boundary must identify the existing body boundary it replaces."));
        return diagnostics;
    }
}

public abstract record BoundedSurfacePatch(
    string PatchId,
    SurfacePatchClass SurfaceClass,
    SurfaceParameterDomain ParameterDomain,
    SurfaceBoundaryLoop BoundaryLoop,
    bool ReversedOrientation)
{
    [JsonIgnore]
    public string GeometryFingerprint => BodyStateId.Derive("SurfacePatch-v1|" + JsonSerializer.Serialize<BoundedSurfacePatch>(this)).Value;
    public abstract SurfaceGeometry Support { get; }
    public abstract Point3D Evaluate(double u, double v);
    public abstract int? DegreeU { get; }
    public abstract int? DegreeV { get; }
    public abstract int? ControlCountU { get; }
    public abstract int? ControlCountV { get; }
    public abstract string ExportClass { get; }
    public abstract IReadOnlyList<SculptDiagnostic> Validate();
}

public sealed record AnalyticSurfacePatch(
    string Id,
    SurfaceGeometry AnalyticSupport,
    SurfaceParameterDomain Domain,
    SurfaceBoundaryLoop Loop,
    Func<double, double, Point3D> Evaluator,
    bool Reversed = false)
    : BoundedSurfacePatch(Id, SurfacePatchClass.Analytic, Domain, Loop, Reversed)
{
    public override SurfaceGeometry Support => AnalyticSupport;
    public override Point3D Evaluate(double u, double v) => Evaluator(u, v);
    public override int? DegreeU => null;
    public override int? DegreeV => null;
    public override int? ControlCountU => null;
    public override int? ControlCountV => null;
    public override string ExportClass => AnalyticSupport.Kind.ToString();
    public override IReadOnlyList<SculptDiagnostic> Validate()
    {
        var diagnostics = Loop.Validate().ToList();
        if (!Domain.IsValid) diagnostics.Add(new("surf-patch-domain-invalid", "The analytic patch parameter domain must be finite and non-empty.", PatchId));
        if (AnalyticSupport.Kind == SurfaceGeometryKind.BSplineSurfaceWithKnots)
            diagnostics.Add(new("surf-patch-class-invalid", "An analytic patch cannot wrap a B-spline support.", PatchId));
        return diagnostics;
    }
}

public sealed record BSplineSurfacePatch : BoundedSurfacePatch
{
    public BSplineSurfacePatch(string patchId, BSplineSurfaceWithKnots spline, SurfaceParameterDomain domain,
        SurfaceBoundaryLoop boundaryLoop, bool reversedOrientation = false,
        SurfacePatchClass surfaceClass = SurfacePatchClass.NonRationalBSpline)
        : base(patchId, surfaceClass, domain, boundaryLoop, reversedOrientation)
    {
        Spline = spline ?? throw new ArgumentNullException(nameof(spline));
    }

    public BSplineSurfaceWithKnots Spline { get; }
    public override SurfaceGeometry Support => SurfaceGeometry.FromBSplineSurfaceWithKnots(Spline);
    public override Point3D Evaluate(double u, double v) => Spline.Evaluate(u, v);
    public override int? DegreeU => Spline.DegreeU;
    public override int? DegreeV => Spline.DegreeV;
    public override int? ControlCountU => Spline.ControlPoints.Count;
    public override int? ControlCountV => Spline.ControlPoints[0].Count;
    public override string ExportClass => "NonRationalBSpline";

    public override IReadOnlyList<SculptDiagnostic> Validate()
    {
        var diagnostics = BoundaryLoop.Validate().ToList();
        if (!ParameterDomain.IsValid || ParameterDomain.UMin < Spline.DomainStartU || ParameterDomain.UMax > Spline.DomainEndU
            || ParameterDomain.VMin < Spline.DomainStartV || ParameterDomain.VMax > Spline.DomainEndV)
            diagnostics.Add(new("surf-patch-domain-invalid", "The bounded patch domain must be finite, non-empty, and contained in the spline knot domain.", PatchId));
        if (SurfaceClass is not (SurfacePatchClass.NonRationalBSpline or SurfacePatchClass.InternalRationalNormalized))
            diagnostics.Add(new("surf-patch-class-invalid", "A B-spline patch must be explicitly non-rational or exactly normalized from removable rationality.", PatchId));
        return diagnostics;
    }
}

public sealed record SurfacePatchMetadata(
    string PatchId,
    SurfacePatchClass SurfaceClass,
    int? DegreeU,
    int? DegreeV,
    int? ControlCountU,
    int? ControlCountV,
    SurfaceParameterDomain ParameterDomain,
    int BoundaryLoops,
    IReadOnlyList<PatchBoundaryCorrespondence> ContinuityContracts,
    string ExportClass)
{
    public static SurfacePatchMetadata From(BoundedSurfacePatch patch, int boundaryLoops = 1) => new(
        patch.PatchId, patch.SurfaceClass, patch.DegreeU, patch.DegreeV, patch.ControlCountU, patch.ControlCountV,
        patch.ParameterDomain, boundaryLoops, patch.BoundaryLoop.Boundaries, patch.ExportClass);
}

public sealed record TrimRegionResult(bool IsSuccess, BoundedSurfacePatch? Patch, IReadOnlyList<SculptDiagnostic> Diagnostics);

public enum SurfaceExtensionMethod { AnalyticIdentity, EndpointTangentContinuation }

public sealed record ExtendedSurfaceSupport(
    SurfaceGeometry OriginalSupport,
    SurfaceParameterDomain OriginalDomain,
    SurfaceParameterDomain ExtendedDomain,
    SurfaceExtensionMethod Method,
    string ContinuityAtOriginalBoundary,
    Func<double, double, Point3D> Evaluator)
{
    public Point3D Evaluate(double u, double v)
    {
        if (u < ExtendedDomain.UMin || u > ExtendedDomain.UMax || v < ExtendedDomain.VMin || v > ExtendedDomain.VMax)
            throw new ArgumentOutOfRangeException(nameof(u), "Evaluation is outside the authorized extension domain.");
        return Evaluator(u, v);
    }
}

public sealed record SurfaceExtensionResult(bool IsSuccess, ExtendedSurfaceSupport? Support, IReadOnlyList<SculptDiagnostic> Diagnostics);

public static class SurfaceSupportExtension
{
    public static SurfaceExtensionResult Extend(SurfaceGeometry support, SurfaceParameterDomain original, SurfaceParameterDomain requested,
        double maximumRelativeExtension = .25d)
    {
        if (!original.IsValid || !requested.IsValid || requested.UMin > original.UMin || requested.UMax < original.UMax
            || requested.VMin > original.VMin || requested.VMax < original.VMax)
            return Failure("surf-extension-domain-invalid", "The requested domain must finitely contain the original domain.");
        var uSpan = original.UMax - original.UMin;
        var vSpan = original.VMax - original.VMin;
        if (original.UMin - requested.UMin > uSpan * maximumRelativeExtension
            || requested.UMax - original.UMax > uSpan * maximumRelativeExtension
            || original.VMin - requested.VMin > vSpan * maximumRelativeExtension
            || requested.VMax - original.VMax > vSpan * maximumRelativeExtension)
            return Failure("surf-extension-unsupported", $"Extension exceeds the bounded {maximumRelativeExtension:P0} per-side stability envelope.");

        if (support.Kind is SurfaceGeometryKind.Plane or SurfaceGeometryKind.Cylinder or SurfaceGeometryKind.Cone)
        {
            Point3D EvaluateAnalytic(double u, double v) => support.Kind switch
            {
                SurfaceGeometryKind.Plane => support.Plane!.Value.Evaluate(u, v),
                SurfaceGeometryKind.Cylinder => support.Cylinder!.Value.Evaluate(u, v),
                SurfaceGeometryKind.Cone => support.Cone!.Value.Evaluate(u, v),
                _ => throw new InvalidOperationException()
            };
            return new(true, new(support, original, requested, SurfaceExtensionMethod.AnalyticIdentity, "Exact analytic continuation", EvaluateAnalytic), []);
        }
        if (support.BSplineSurfaceWithKnots is not { } spline)
            return Failure("surf-extension-unsupported", $"Surface family {support.Kind} is not in the bounded extension matrix.");
        if (spline.DegreeU > 3 || spline.DegreeV > 3 || spline.SelfIntersect)
            return Failure("surf-extension-unsupported", "Endpoint-tangent continuation is limited to non-self-intersecting degree <= 3 B-spline supports.");

        Point3D EvaluateSpline(double u, double v)
        {
            var uc = System.Math.Clamp(u, original.UMin, original.UMax);
            var vc = System.Math.Clamp(v, original.VMin, original.VMax);
            var basePoint = spline.Evaluate(uc, vc);
            var hu = double.Max(uSpan * 1e-4d, 1e-7d);
            var hv = double.Max(vSpan * 1e-4d, 1e-7d);
            var u0 = System.Math.Clamp(uc - hu, original.UMin, original.UMax);
            var u1 = System.Math.Clamp(uc + hu, original.UMin, original.UMax);
            var v0 = System.Math.Clamp(vc - hv, original.VMin, original.VMax);
            var v1 = System.Math.Clamp(vc + hv, original.VMin, original.VMax);
            var du = (spline.Evaluate(u1, vc) - spline.Evaluate(u0, vc)) / (u1 - u0);
            var dv = (spline.Evaluate(uc, v1) - spline.Evaluate(uc, v0)) / (v1 - v0);
            return basePoint + (du * (u - uc)) + (dv * (v - vc));
        }
        return new(true, new(support, original, requested, SurfaceExtensionMethod.EndpointTangentContinuation,
            "C1 by endpoint first-derivative continuation; mixed outside-corner term intentionally zero", EvaluateSpline), []);
    }

    private static SurfaceExtensionResult Failure(string code, string message) => new(false, null, [new(code, message)]);
}

public static class SurfacePatchOperations
{
    public static TrimRegionResult TrimRegion(BSplineSurfacePatch patch, SurfaceParameterDomain domain)
    {
        var trimmed = patch with { ParameterDomain = domain };
        var diagnostics = trimmed.Validate();
        return diagnostics.Count == 0 ? new(true, trimmed, []) : new(false, null, diagnostics);
    }

    public static TrimRegionResult ExtendRegion(BSplineSurfacePatch patch, SurfaceParameterDomain domain)
    {
        if (domain.UMin < patch.Spline.DomainStartU || domain.UMax > patch.Spline.DomainEndU
            || domain.VMin < patch.Spline.DomainStartV || domain.VMax > patch.Spline.DomainEndV)
            return new(false, null, [new("surf-extend-law-unsupported", "A non-rational B-spline may only be extended into its existing knot support in SURF-X1; arbitrary extrapolation is not defined.", patch.PatchId)]);
        return TrimRegion(patch, domain);
    }
}