Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

14.0 KB
Raw Blame
using Aetheris.Kernel.Core.Geometry.Curves;
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Topology;

namespace Aetheris.Kernel.Core.Brep;

public readonly record struct EdgeGeometryBinding(
    EdgeId EdgeId,
    CurveGeometryId CurveGeometryId,
    ParameterInterval? TrimInterval = null,
    bool OrientedEdgeSense = true)
{
    public int? SourceStepEntityId { get; init; }
}

/// <summary>
/// Canonical face orientation after topology/material-side resolution.  This is
/// intentionally not a STEP <c>same_sense</c> flag: interchange evidence is
/// retained separately on <see cref="BrepBody.FaceOrientationReport"/>.
/// </summary>
public readonly record struct ResolvedFaceOrientation(bool IsAlignedWithSurface)
{
    public static ResolvedFaceOrientation Aligned { get; } = new(true);
    public static ResolvedFaceOrientation Opposed { get; } = new(false);

    public ResolvedFaceOrientation Reversed() => new(!IsAlignedWithSurface);
}

/// <summary>A topology-to-surface binding whose face orientation is already resolved.</summary>
public readonly record struct FaceGeometryBinding
{
    // Keep the historical bool constructor shape for authored kernel geometry,
    // while exposing only the resolved typed value to consumers.
    public FaceGeometryBinding(
        FaceId FaceId,
        SurfaceGeometryId SurfaceGeometryId,
        bool IsAlignedWithSurface = true,
        int? SourceStepEntityId = null)
        : this(FaceId, SurfaceGeometryId, new ResolvedFaceOrientation(IsAlignedWithSurface), SourceStepEntityId)
    {
    }

    public FaceGeometryBinding(
        FaceId FaceId,
        SurfaceGeometryId SurfaceGeometryId,
        ResolvedFaceOrientation Orientation,
        int? SourceStepEntityId = null)
    {
        this.FaceId = FaceId;
        this.SurfaceGeometryId = SurfaceGeometryId;
        this.Orientation = Orientation;
        this.SourceStepEntityId = SourceStepEntityId;
    }

    public FaceId FaceId { get; init; }
    public SurfaceGeometryId SurfaceGeometryId { get; init; }
    public ResolvedFaceOrientation Orientation { get; init; }
    public int? SourceStepEntityId { get; init; }
}

public readonly record struct SurfaceParameterPoint(double U, double V);

public enum PcurveGeometryKind { Line, Circle, Ellipse, Polyline, Polynomial }

/// <summary>A face-local parameter-space curve with the same parameter as its bound 3D edge.</summary>
public sealed record PcurveGeometry
{
    private PcurveGeometry(PcurveGeometryKind kind, ParameterInterval domain, IReadOnlyList<SurfaceParameterPoint> points)
    {
        Kind = kind;
        Domain = domain;
        Points = points;
    }

    public BSpline3Curve? PolynomialCurve { get; private init; }
    public IReadOnlyList<double>? RationalWeights { get; private init; }
    public PcurveGeometryKind Kind { get; }
    public ParameterInterval Domain { get; }
    public IReadOnlyList<SurfaceParameterPoint> Points { get; }

    public static PcurveGeometry Line(ParameterInterval domain, SurfaceParameterPoint start, SurfaceParameterPoint end)
        => new(PcurveGeometryKind.Line, domain, [start, end]);

    public static PcurveGeometry Circle(ParameterInterval domain, SurfaceParameterPoint center, double radiusU, double radiusV)
        => new(PcurveGeometryKind.Circle, domain, [center, new(radiusU, radiusV)]);

    public static PcurveGeometry Ellipse(ParameterInterval domain, SurfaceParameterPoint center,
        SurfaceParameterPoint cosineCoefficient, SurfaceParameterPoint sineCoefficient)
        => new(PcurveGeometryKind.Ellipse, domain, [center, cosineCoefficient, sineCoefficient]);

    public static PcurveGeometry Polyline(ParameterInterval domain, IReadOnlyList<SurfaceParameterPoint> points)
        => new(PcurveGeometryKind.Polyline, domain, points.ToArray());

    /// <summary>Reuses the polynomial curve authority in the UV plane (Z must be zero).</summary>
    public static PcurveGeometry Polynomial(ParameterInterval domain, BSpline3Curve curve)
    {
        if (!double.IsFinite(domain.Start) || !double.IsFinite(domain.End) || domain.Start == domain.End ||
            System.Math.Min(domain.Start, domain.End) < curve.DomainStart || System.Math.Max(domain.Start, domain.End) > curve.DomainEnd ||
            curve.ControlPoints.Any(p => !double.IsFinite(p.X) || !double.IsFinite(p.Y) || p.Z != 0))
            throw new ArgumentException("Polynomial pcurve requires a finite in-domain trim and UV-plane controls.");
        return new(PcurveGeometryKind.Polynomial, domain, []) { PolynomialCurve = curve };
    }

    public static PcurveGeometry RationalPolynomial(ParameterInterval domain, BSpline3Curve curve, IReadOnlyList<double> weights)
    {
        if (weights.Count != curve.ControlPoints.Count || weights.Any(weight => !double.IsFinite(weight) || weight <= 0d))
            throw new ArgumentException("Rational pcurve weights must be finite, positive, and match the control points.");
        var polynomial = Polynomial(domain, curve);
        return polynomial with { RationalWeights = weights.ToArray() };
    }

    public SurfaceParameterPoint Evaluate(double parameter)
    {
        var span = Domain.End - Domain.Start;
        var fraction = double.Abs(span) <= 1e-15d ? 0d : System.Math.Clamp((parameter - Domain.Start) / span, 0d, 1d);
        if (PolynomialCurve is { } polynomial)
        {
            if (RationalWeights is { } weights)
                return EvaluateRational(polynomial, weights, Domain.Start + span * fraction);
            var point = polynomial.Evaluate(Domain.Start + span * fraction);
            return new(point.X, point.Y);
        }
        if (Kind == PcurveGeometryKind.Circle)
        {
            var angle = Domain.Start + (span * fraction);
            return new(Points[0].U + (Points[1].U * double.Cos(angle)), Points[0].V + (Points[1].V * double.Sin(angle)));
        }
        if (Kind == PcurveGeometryKind.Ellipse)
        {
            var angle = Domain.Start + (span * fraction);
            return new(Points[0].U + (Points[1].U * double.Cos(angle)) + (Points[2].U * double.Sin(angle)),
                Points[0].V + (Points[1].V * double.Cos(angle)) + (Points[2].V * double.Sin(angle)));
        }
        if (Kind == PcurveGeometryKind.Line)
            return Lerp(Points[0], Points[1], fraction);
        if (Points.Count == 0) return default;
        if (Points.Count == 1) return Points[0];
        var scaled = fraction * (Points.Count - 1);
        var index = System.Math.Min((int)double.Floor(scaled), Points.Count - 2);
        return Lerp(Points[index], Points[index + 1], scaled - index);
    }

    private static SurfaceParameterPoint Lerp(SurfaceParameterPoint a, SurfaceParameterPoint b, double t)
        => new(a.U + ((b.U - a.U) * t), a.V + ((b.V - a.V) * t));

    private static SurfaceParameterPoint EvaluateRational(BSpline3Curve curve, IReadOnlyList<double> weights, double parameter)
    {
        var u = System.Math.Clamp(parameter, curve.DomainStart, curve.DomainEnd);
        var basis = new double[curve.ControlPoints.Count];
        for (var i = 0; i < basis.Length; i++)
            basis[i] = (u >= curve.FullKnots[i] && u < curve.FullKnots[i + 1])
                || (u == curve.DomainEnd && i == basis.Length - 1) ? 1d : 0d;
        for (var degree = 1; degree <= curve.Degree; degree++)
        {
            var next = new double[basis.Length];
            for (var i = 0; i < basis.Length; i++)
            {
                var leftDenominator = curve.FullKnots[i + degree] - curve.FullKnots[i];
                var rightDenominator = i + degree + 1 < curve.FullKnots.Count
                    ? curve.FullKnots[i + degree + 1] - curve.FullKnots[i + 1] : 0d;
                var left = leftDenominator == 0d ? 0d : (u - curve.FullKnots[i]) / leftDenominator * basis[i];
                var right = i + 1 >= basis.Length || rightDenominator == 0d
                    ? 0d : (curve.FullKnots[i + degree + 1] - u) / rightDenominator * basis[i + 1];
                next[i] = left + right;
            }
            basis = next;
        }
        var sumU = 0d;
        var sumV = 0d;
        var denominator = 0d;
        for (var i = 0; i < basis.Length; i++)
        {
            var weighted = basis[i] * weights[i];
            sumU += curve.ControlPoints[i].X * weighted;
            sumV += curve.ControlPoints[i].Y * weighted;
            denominator += weighted;
        }
        if (double.Abs(denominator) <= 1e-15d) return default;
        return new(sumU / denominator, sumV / denominator);
    }
}

/// <summary>Associates one coedge use with its curve in the owning face's UV space.</summary>
public readonly record struct CoedgePcurveBinding(
    CoedgeId CoedgeId,
    FaceId FaceId,
    SurfaceGeometryId SurfaceGeometryId,
    PcurveGeometry Pcurve,
    bool SameSense = true,
    int? SourceStepPcurveEntityId = null,
    int? SourceStepCurveEntityId = null,
    string? SourceCurveType = null,
    int? SourceStepSurfaceEntityId = null,
    PcurveQualification? Qualification = null);

/// <summary>Where a face-local trim came from. <see cref="ConstructedBoundary"/>: the edge is, by
/// construction, an isoparametric boundary of the face's own surface, so the trim is the matching
/// straight line of its parameter rectangle (BUILD-PERF-M4: no inverse projection or dense lift).</summary>
public enum PcurveBindingOrigin { SourceValidated, RecoveredAnalytic, RecoveredSpline, DerivedAnalytic, ConstructedBoundary }

/// <summary>Edge-to-surface-lift evidence for one face-local trim. BezierBoundaryControlHull
/// reports a whole-span upper bound with zero samples. RecoveryMethod identifies the evidence.</summary>
public sealed record PcurveQualification(
    PcurveBindingOrigin Origin,
    double MaximumLiftDeviationMillimetres,
    double QualificationToleranceMillimetres,
    int LiftSamples,
    string RecoveryMethod,
    string SurfaceFamily);

public enum FaceBoundaryRole { Outer, Inner }

/// <summary>
/// Semantic role of one loop within one face. The role is use-context evidence:
/// it must not be reconstructed from LoopId ordering during STEP export.
/// </summary>
public readonly record struct FaceBoundaryRoleBinding(
    FaceId FaceId,
    LoopId LoopId,
    FaceBoundaryRole Role,
    int? SourceStepEntityId = null);

/// <summary>Face-local parameter location and provenance for an explicit STEP VERTEX_LOOP.</summary>
public readonly record struct VertexLoopParameterBinding(
    LoopId LoopId,
    FaceId FaceId,
    SurfaceGeometryId SurfaceGeometryId,
    VertexId VertexId,
    SurfaceParameterPoint? Parameter,
    int? SourceStepLoopEntityId = null,
    int? SourceStepVertexEntityId = null);

/// <summary>
/// Explicit topology-to-geometry binding container.
/// </summary>
public sealed class BrepBindingModel
{
    private readonly Dictionary<EdgeId, EdgeGeometryBinding> _edgeBindings = [];
    private readonly Dictionary<FaceId, FaceGeometryBinding> _faceBindings = [];
    private readonly Dictionary<CoedgeId, CoedgePcurveBinding> _pcurveBindings = [];
    private readonly Dictionary<LoopId, FaceBoundaryRoleBinding> _faceBoundaryRoleBindings = [];
    private readonly Dictionary<LoopId, VertexLoopParameterBinding> _vertexLoopParameterBindings = [];

    public IEnumerable<EdgeGeometryBinding> EdgeBindings => _edgeBindings.Values;

    public IEnumerable<FaceGeometryBinding> FaceBindings => _faceBindings.Values;
    public IEnumerable<CoedgePcurveBinding> PcurveBindings => _pcurveBindings.Values;
    public IEnumerable<FaceBoundaryRoleBinding> FaceBoundaryRoleBindings => _faceBoundaryRoleBindings.Values;
    public IEnumerable<VertexLoopParameterBinding> VertexLoopParameterBindings => _vertexLoopParameterBindings.Values;

    /// <summary>An independent binding model with the same (immutable) bindings in the same order.</summary>
    public BrepBindingModel Clone()
    {
        var copy = new BrepBindingModel();
        foreach (var (id, binding) in _edgeBindings) copy._edgeBindings.Add(id, binding);
        foreach (var (id, binding) in _faceBindings) copy._faceBindings.Add(id, binding);
        foreach (var (id, binding) in _pcurveBindings) copy._pcurveBindings.Add(id, binding);
        foreach (var (id, binding) in _faceBoundaryRoleBindings) copy._faceBoundaryRoleBindings.Add(id, binding);
        foreach (var (id, binding) in _vertexLoopParameterBindings) copy._vertexLoopParameterBindings.Add(id, binding);
        return copy;
    }

    public void AddEdgeBinding(EdgeGeometryBinding binding) => _edgeBindings.Add(binding.EdgeId, binding);

    public void AddFaceBinding(FaceGeometryBinding binding) => _faceBindings.Add(binding.FaceId, binding);
    public void AddPcurveBinding(CoedgePcurveBinding binding) => _pcurveBindings.Add(binding.CoedgeId, binding);
    public void AddFaceBoundaryRoleBinding(FaceBoundaryRoleBinding binding) => _faceBoundaryRoleBindings.Add(binding.LoopId, binding);
    public void AddVertexLoopParameterBinding(VertexLoopParameterBinding binding) => _vertexLoopParameterBindings.Add(binding.LoopId, binding);

    public bool TryGetEdgeBinding(EdgeId edgeId, out EdgeGeometryBinding binding) => _edgeBindings.TryGetValue(edgeId, out binding);

    public bool TryGetFaceBinding(FaceId faceId, out FaceGeometryBinding binding) => _faceBindings.TryGetValue(faceId, out binding);
    public bool TryGetPcurveBinding(CoedgeId coedgeId, out CoedgePcurveBinding binding) => _pcurveBindings.TryGetValue(coedgeId, out binding);
    public bool TryGetFaceBoundaryRoleBinding(LoopId loopId, out FaceBoundaryRoleBinding binding) => _faceBoundaryRoleBindings.TryGetValue(loopId, out binding);
    public bool TryGetVertexLoopParameterBinding(LoopId loopId, out VertexLoopParameterBinding binding) => _vertexLoopParameterBindings.TryGetValue(loopId, out binding);

    public EdgeGeometryBinding GetEdgeBinding(EdgeId edgeId) => _edgeBindings[edgeId];

    public FaceGeometryBinding GetFaceBinding(FaceId faceId) => _faceBindings[faceId];
    public CoedgePcurveBinding GetPcurveBinding(CoedgeId coedgeId) => _pcurveBindings[coedgeId];
    public FaceBoundaryRoleBinding GetFaceBoundaryRoleBinding(LoopId loopId) => _faceBoundaryRoleBindings[loopId];
    public VertexLoopParameterBinding GetVertexLoopParameterBinding(LoopId loopId) => _vertexLoopParameterBindings[loopId];
}