Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Topology;
namespace Aetheris.Kernel.Core.Brep;
public sealed record BrepPcurveEvidence(
bool IsValid,
int EdgeCount,
int PcurveCount,
double MaximumReconstructionDeviation,
bool DomainValid,
bool OrientationConsistent,
IReadOnlyList<string> Diagnostics)
{
public bool LoopClosureValid { get; init; }
public double MaximumUvLoopClosure { get; init; }
public double RootMeanSquareReconstructionDeviation { get; init; }
}
/// <summary>Source-local topology evidence for collapsed trim vertices; omitted by authored callers.</summary>
public sealed record BrepPcurveTopologyEvidence(
IReadOnlyDictionary<VertexId, double> VertexTolerancesMillimetres,
IReadOnlySet<(CoedgeId Current, CoedgeId Next)> CollapsedSingularTransitions);
/// <summary>Independently samples face-local pcurves against their shared 3D edge geometry.</summary>
public static class BrepPcurveValidator
{
public static BrepPcurveEvidence Validate(BrepBody body, double tolerance = 1e-6, bool requireEveryCoedge = false, int samples = 67,
BrepPcurveTopologyEvidence? sourceTopology = null)
{
ArgumentNullException.ThrowIfNull(body);
if (!double.IsFinite(tolerance) || tolerance <= 0d) throw new ArgumentOutOfRangeException(nameof(tolerance));
if (samples < 3) throw new ArgumentOutOfRangeException(nameof(samples));
var diagnostics = new List<string>();
var maximum = 0d;
var domainValid = true;
var orientationValid = true;
var loopClosureValid = true;
var maximumUvClosure = 0d;
var squaredResidual = 0d;
var residualSamples = 0;
foreach (var coedge in body.Topology.Coedges.OrderBy(item => item.Id.Value))
{
var coedgeMaximum = 0d;
if (!body.Bindings.TryGetPcurveBinding(coedge.Id, out var binding))
{
if (requireEveryCoedge) diagnostics.Add($"surf-pcurve-missing:coedge={coedge.Id.Value}");
continue;
}
var bindingTolerance = binding.Qualification?.QualificationToleranceMillimetres ?? tolerance;
var face = body.Topology.Faces.SingleOrDefault(candidate => candidate.LoopIds.Contains(coedge.LoopId));
if (face is null || face.Id != binding.FaceId)
{
diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:owning-face-mismatch");
continue;
}
if (!body.Bindings.TryGetFaceBinding(face.Id, out var faceBinding) || faceBinding.SurfaceGeometryId != binding.SurfaceGeometryId
|| !body.Geometry.TryGetSurface(binding.SurfaceGeometryId, out var surface) || surface is null
|| !body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var edgeBinding)
|| !body.Geometry.TryGetCurve(edgeBinding.CurveGeometryId, out var curve) || curve is null)
{
diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:binding-reference");
continue;
}
var interval = edgeBinding.TrimInterval ?? binding.Pcurve.Domain;
if (!FiniteOrdered(binding.Pcurve.Domain) || (binding.Pcurve.Points.Count == 0 && binding.Pcurve.PolynomialCurve is null))
{
domainValid = false;
diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:domain");
continue;
}
for (var index = 0; index < samples; index++)
{
var fraction = index / (double)(samples - 1);
var parameter = interval.Start + ((interval.End - interval.Start) * fraction);
var curveParameter = binding.SameSense ? parameter : interval.End - ((parameter - interval.Start));
var uv = binding.Pcurve.Evaluate(curveParameter);
if (!WithinSurfaceDomain(surface, uv, bindingTolerance))
{
domainValid = false;
diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:surface-domain:u={uv.U:R}:v={uv.V:R}");
break;
}
var onSurface = Evaluate(surface, uv);
var onCurve = Evaluate(curve, parameter);
if (onSurface is null || onCurve is null)
{
diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:unsupported-evaluator");
break;
}
coedgeMaximum = double.Max(coedgeMaximum, (onSurface.Value - onCurve.Value).Length);
squaredResidual += (onSurface.Value - onCurve.Value).LengthSquared;
residualSamples++;
}
maximum = double.Max(maximum, coedgeMaximum);
if (coedgeMaximum > bindingTolerance)
diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:face={face.Id.Value}:surface={surface.Kind}:curve={curve.Kind}:pcurve={binding.Pcurve.Kind}:deviation={coedgeMaximum:R}:tolerance={bindingTolerance:R}");
// The coedge runs from its first vertex to its last. Which trim end that is depends on both the
// coedge's use of the edge and the edge's sense along its curve (EDGE_CURVE same_sense).
var runsAgainstCurve = coedge.IsReversed ^ !edgeBinding.OrientedEdgeSense;
var startVertexId = coedge.IsReversed ? body.Topology.GetEdge(coedge.EdgeId).EndVertexId : body.Topology.GetEdge(coedge.EdgeId).StartVertexId;
if (body.TryGetVertexPoint(startVertexId, out var start))
{
var parameter = runsAgainstCurve ? interval.End : interval.Start;
var uv = binding.Pcurve.Evaluate(binding.SameSense ? parameter : interval.End - (parameter - interval.Start));
var reconstructed = Evaluate(surface, uv);
var vertexTolerance = sourceTopology?.VertexTolerancesMillimetres.GetValueOrDefault(startVertexId) ?? 0d;
if (reconstructed is null || (reconstructed.Value - start).Length > double.Max(bindingTolerance, vertexTolerance))
{
orientationValid = false;
diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:orientation");
}
}
var edge = body.Topology.GetEdge(coedge.EdgeId);
var endVertex = coedge.IsReversed ? edge.StartVertexId : edge.EndVertexId;
if (body.TryGetVertexPoint(endVertex, out var endPoint))
{
var parameter = runsAgainstCurve ? interval.Start : interval.End;
var uv = binding.Pcurve.Evaluate(binding.SameSense ? parameter : interval.End - (parameter - interval.Start));
var reconstructed = Evaluate(surface, uv);
var vertexTolerance = sourceTopology?.VertexTolerancesMillimetres.GetValueOrDefault(endVertex) ?? 0d;
if (reconstructed is null || (reconstructed.Value - endPoint).Length > double.Max(bindingTolerance, vertexTolerance))
{
orientationValid = false;
diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:end-orientation");
}
}
var next = body.Topology.GetCoedge(coedge.NextCoedgeId);
if (body.Bindings.TryGetPcurveBinding(next.Id, out var nextBinding)
&& body.Bindings.TryGetEdgeBinding(next.EdgeId, out var nextEdgeBinding)
&& nextEdgeBinding.TrimInterval is { } nextInterval)
{
var nextRunsAgainstCurve = next.IsReversed ^ !nextEdgeBinding.OrientedEdgeSense;
var currentLoopParameter = runsAgainstCurve ? interval.Start : interval.End;
var nextLoopParameter = nextRunsAgainstCurve ? nextInterval.End : nextInterval.Start;
var currentUv = binding.Pcurve.Evaluate(binding.SameSense ? currentLoopParameter : interval.End - (currentLoopParameter - interval.Start));
var nextUv = nextBinding.Pcurve.Evaluate(nextBinding.SameSense ? nextLoopParameter : nextInterval.End - (nextLoopParameter - nextInterval.Start));
var closure = UvDistance(surface, currentUv, nextUv);
maximumUvClosure = double.Max(maximumUvClosure, closure);
// Two edges that each end within the source's vertex tolerance of their shared vertex may
// stop up to twice that apart; in UV that is checked in model space below.
var sharedVertex = runsAgainstCurve ? body.Topology.GetEdge(coedge.EdgeId).StartVertexId : body.Topology.GetEdge(coedge.EdgeId).EndVertexId;
var sharedVertexTolerance = sourceTopology?.VertexTolerancesMillimetres.GetValueOrDefault(sharedVertex) ?? 0d;
var closureTolerance = double.Max(bindingTolerance,
nextBinding.Qualification?.QualificationToleranceMillimetres ?? tolerance);
if (sourceTopology?.CollapsedSingularTransitions.Contains((coedge.Id, next.Id)) == true)
{
// The omitted Rhino singular trim crosses UV while lifting to one vertex.
// Check its two lifted endpoints in model space against that source vertex.
var currentLift = Evaluate(surface, currentUv);
var nextLift = Evaluate(surface, nextUv);
var vertex = coedge.IsReversed ? edge.StartVertexId : edge.EndVertexId;
var sourceLimit = sourceTopology.VertexTolerancesMillimetres.GetValueOrDefault(vertex);
if (currentLift is null || nextLift is null || !body.TryGetVertexPoint(vertex, out var vertexPoint)
|| (currentLift.Value - vertexPoint).Length > double.Max(closureTolerance, sourceLimit)
|| (nextLift.Value - vertexPoint).Length > double.Max(closureTolerance, sourceLimit))
{
loopClosureValid = false;
diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:collapsed-singular-lift");
}
}
else if (closure > closureTolerance && !MeetAtSingularPoint(surface, currentUv, nextUv, closureTolerance)
&& !(sharedVertexTolerance > 0d && Evaluate(surface, currentUv) is { } liftA && Evaluate(surface, nextUv) is { } liftB
&& (liftA - liftB).Length <= 2d * sharedVertexTolerance + closureTolerance))
{
loopClosureValid = false;
diagnostics.Add($"surf-pcurve-invalid:coedge={coedge.Id.Value}:uv-loop-closure={closure:R}:tolerance={closureTolerance:R}");
}
}
}
var count = body.Bindings.PcurveBindings.Count();
var valid = diagnostics.Count == 0 && domainValid && orientationValid && loopClosureValid;
return new(valid, body.Topology.Edges.Count(), count, maximum, domainValid, orientationValid, diagnostics)
{
LoopClosureValid = loopClosureValid,
MaximumUvLoopClosure = maximumUvClosure,
RootMeanSquareReconstructionDeviation = residualSamples == 0 ? 0d : double.Sqrt(squaredResidual / residualSamples)
};
}
/// <summary>A sphere pole or cone apex is one model point for every U: two pcurves can meet there
/// with any U gap. Accept when both ends lift to the same point and U is degenerate at it.</summary>
private static bool MeetAtSingularPoint(SurfaceGeometry surface, SurfaceParameterPoint a, SurfaceParameterPoint b, double tolerance)
{
if (Evaluate(surface, a) is not { } pa || Evaluate(surface, b) is not { } pb || (pa - pb).Length > tolerance) return false;
bool Degenerate(SurfaceParameterPoint uv, Point3D p)
=> Evaluate(surface, new SurfaceParameterPoint(uv.U + 1e-3, uv.V)) is { } q && (q - p).Length <= tolerance;
return Degenerate(a, pa) && Degenerate(b, pb);
}
private static bool WithinSurfaceDomain(SurfaceGeometry surface, SurfaceParameterPoint uv, double tolerance)
{
if (!double.IsFinite(uv.U) || !double.IsFinite(uv.V)) return false;
if (surface.BSplineSurfaceWithKnots is not { } spline) return true;
return uv.U >= spline.DomainStartU - tolerance && uv.U <= spline.DomainEndU + tolerance
&& uv.V >= spline.DomainStartV - tolerance && uv.V <= spline.DomainEndV + tolerance;
}
private static double UvDistance(SurfaceGeometry surface, SurfaceParameterPoint a, SurfaceParameterPoint b)
{
// Distinct generator angles meet at one exact cone apex. Comparing U
// there rejects a closed boundary solely because its chart is singular.
if (surface.Cone is not null && double.Abs(a.V) <= 1e-10 && double.Abs(b.V) <= 1e-10)
return double.Abs(a.V - b.V);
var periodicity = SurfacePeriodicity.Of(surface);
var du = PeriodicDelta(a.U - b.U, periodicity.UPeriod);
var dv = PeriodicDelta(a.V - b.V, periodicity.VPeriod);
return double.Sqrt((du * du) + (dv * dv));
}
private static double PeriodicDelta(double delta, double? period)
=> period is double value && value > 0d && double.IsFinite(value)
? delta - double.Round(delta / value) * value
: delta;
private static bool FiniteOrdered(ParameterInterval interval) => double.IsFinite(interval.Start) && double.IsFinite(interval.End) && interval.End >= interval.Start;
private static Point3D? Evaluate(SurfaceGeometry surface, SurfaceParameterPoint uv) => surface.Kind switch
{
SurfaceGeometryKind.Plane => surface.Plane!.Value.Evaluate(uv.U, uv.V),
SurfaceGeometryKind.Cylinder => surface.Cylinder!.Value.Evaluate(uv.U, uv.V),
SurfaceGeometryKind.Cone => surface.Cone!.Value.Evaluate(uv.U, uv.V),
SurfaceGeometryKind.Sphere => surface.Sphere!.Value.Evaluate(uv.U, uv.V),
SurfaceGeometryKind.Torus => surface.Torus!.Value.Evaluate(uv.U, uv.V),
SurfaceGeometryKind.Ellipsoid => surface.Ellipsoid!.Evaluate(uv.U, uv.V),
SurfaceGeometryKind.BSplineSurfaceWithKnots => surface.BSplineSurfaceWithKnots!.Evaluate(uv.U, uv.V),
_ => null
};
internal static Point3D? Evaluate(CurveGeometry curve, double parameter) => curve.Kind switch
{
CurveGeometryKind.Line3 => curve.Line3!.Value.Evaluate(parameter),
CurveGeometryKind.Circle3 => curve.Circle3!.Value.Evaluate(parameter),
CurveGeometryKind.BSpline3 => curve.BSpline3!.Value.Evaluate(parameter),
CurveGeometryKind.Ellipse3 => curve.Ellipse3!.Value.Evaluate(parameter),
CurveGeometryKind.Hyperbola3 => curve.Hyperbola3!.Value.Evaluate(parameter),
_ => null
};
}