Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
using Aetheris.Kernel.Core.Diagnostics;
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Geometry.Curves;
using Aetheris.Kernel.Core.Geometry.Surfaces;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Results;
using Aetheris.Kernel.Core.Topology;
namespace Aetheris.Kernel.Core.Brep.Tessellation;
public static class BrepDisplayTessellator
{
private const double LoopEndpointTolerance = 1e-6d;
private const string PlanarCurveFlatteningUnsupportedSource = "Viewer.Tessellation.PlanarCurveFlatteningUnsupported";
private const string PlanarCurveFlatteningFailedSource = "Viewer.Tessellation.PlanarCurveFlatteningFailed";
private const string CircleTrimResolveFailedSource = "Viewer.Tessellation.CircleTrimResolveFailed";
private const string CircleTrimAmbiguousUsedShorterArcSource = "Viewer.Tessellation.CircleTrimAmbiguousUsedShorterArc";
private const string CylinderTrimUnsupportedSource = "Viewer.Tessellation.CylinderTrimUnsupported";
private const string CylinderTrimDegenerateSource = "Viewer.Tessellation.CylinderTrimDegenerate";
private const string CylinderTrimAxialSpanDegenerateSource = "Viewer.Tessellation.CylinderTrimAxialSpanDegenerate";
private const string CylinderTrimAxialSpanDegenerateSingleCoedgeNearFullWrapSource = "Viewer.Tessellation.CylinderTrimAxialSpanDegenerate.SingleCoedgeNearFullWrap";
private const string CylinderTrimAxialSpanDegenerateSingleCoedgeSource = "Viewer.Tessellation.CylinderTrimAxialSpanDegenerate.SingleCoedge";
private const string CylinderTrimAxialSpanDegenerateMultiCoedgeSource = "Viewer.Tessellation.CylinderTrimAxialSpanDegenerate.MultiCoedge";
private const string CylinderTrimAxialSpanDegenerateSingleCoedgeNearFullWrapBridgeSource = "Viewer.Tessellation.CylinderTrimAxialSpanDegenerate.SingleCoedgeNearFullWrapBridge";
private const string CylinderTrimAmbiguousUsedShorterSpanSource = "Viewer.Tessellation.CylinderTrimAmbiguousUsedShorterSpan";
private const string CylinderTrimDualSingleCoedgeClosedCircleSource = "Viewer.Tessellation.CylinderTrim.DualSingleCoedgeClosedCircle";
private const string CurvedTopologyUnsupportedSource = "Viewer.Tessellation.CurvedTopologyUnsupported";
private const string BSplineSurfaceTrimUnsupportedSource = "Viewer.Tessellation.BSplineSurfaceTrimUnsupported";
private const string PlanarMultiLoopTriangulationSkippedSource = "Viewer.Tessellation.PlanarMultiLoopTriangulationSkipped";
private const string TrimEvaluationFailedSource = "Viewer.Tessellation.TrimEvaluationFailed";
public static KernelResult<DisplayTessellationResult> Tessellate(BrepBody body, DisplayTessellationOptions? options = null)
=> TessellateCore(body, options, null);
/// <summary>Migration oracle used by focused comparisons; it is not the default display route.</summary>
internal static KernelResult<DisplayTessellationResult> TessellateLegacyForComparison(BrepBody body, DisplayTessellationOptions? options = null)
=> TessellateCore(body, options, null);
/// <summary>Explicit M3 SurfaceMeshIR route; unsupported trim families are reported rather than silently downgraded.</summary>
public static KernelResult<DisplayTessellationResult> TessellateSurfaceMeshIr(BrepBody body, DisplayTessellationOptions? options = null)
{
var effectiveOptions = options ?? DisplayTessellationOptions.Default;
return SurfaceMeshIrTessellator.TryTessellate(body, effectiveOptions, out var result)
? KernelResult<DisplayTessellationResult>.Success(result)
: KernelResult<DisplayTessellationResult>.Failure([CreateNotImplemented("SurfaceMeshIR supports admitted planar/conic bands, closed sphere charts, bounded convex sphere/ellipsoid trims and admitted torus patches. General arbitrary trimmed-patch remeshing remains unsupported by this route.", "Viewer.SurfaceMeshIr.Unsupported")]);
}
public static KernelResult<DisplayTessellationResult> TessellateBounded(
BrepBody body,
DisplayTessellationOptions? options = null,
TimeSpan? executionTimeout = null)
=> TessellateCore(body, options, new DisplayTessellationExecutionBudget(executionTimeout ?? TimeSpan.FromSeconds(5)));
public static DisplayTessellationResult TessellateBoundedPartial(
BrepBody body,
DisplayTessellationOptions? options = null,
TimeSpan? executionTimeout = null)
{
var effectiveOptions = options ?? DisplayTessellationOptions.Default;
var executionBudget = new DisplayTessellationExecutionBudget(executionTimeout ?? TimeSpan.FromSeconds(5));
var facePatches = new List<DisplayFaceMeshPatch>();
var faceDiagnostics = new List<DisplayFaceMaterializationDiagnostic>();
foreach (var face in body.Topology.Faces.OrderBy(f => f.Id.Value))
{
var surfaceKind = TryGetSurfaceKind(body, face.Id);
try
{
executionBudget.ThrowIfExpired("FaceDispatch", face.Id, surfaceKind);
var faceResult = ExecuteWithinOptionalBudget(
() => TessellateFace(body, face.Id, effectiveOptions, executionBudget),
executionBudget,
"FaceTessellation",
face.Id,
surfaceKind,
executionBudget.Remaining + TimeSpan.FromMilliseconds(250));
foreach (var diagnostic in faceResult.Diagnostics)
{
faceDiagnostics.Add(new DisplayFaceMaterializationDiagnostic(
face.Id,
surfaceKind?.ToString(),
ExtractPhase(diagnostic.Message),
diagnostic.Source ?? diagnostic.Code.ToString(),
diagnostic.Message));
}
// A successful partial result can be an empty patch with a trim
// rejection warning. Keep that warning alongside the retained mesh.
if (faceResult.IsSuccess)
facePatches.Add(faceResult.Value);
}
catch (DisplayTessellationTimeoutException ex)
{
faceDiagnostics.Add(new DisplayFaceMaterializationDiagnostic(
ex.FaceId ?? face.Id,
ex.SurfaceKind?.ToString() ?? surfaceKind?.ToString(),
ex.Phase,
"Viewer.Tessellation.Timeout",
ex.Message));
}
}
var edgePolylines = new List<DisplayEdgePolyline>();
foreach (var edge in body.Topology.Edges.OrderBy(e => e.Id.Value))
{
try
{
var edgeResult = TessellateEdge(body, edge.Id, effectiveOptions);
if (edgeResult.IsSuccess)
{
edgePolylines.Add(edgeResult.Value);
}
}
catch (DisplayTessellationTimeoutException)
{
break;
}
}
return new DisplayTessellationResult(facePatches, edgePolylines, faceDiagnostics);
}
private static string ExtractPhase(string message)
{
const string marker = "during phase '";
var start = message.IndexOf(marker, StringComparison.Ordinal);
if (start < 0) return "FaceTessellation";
start += marker.Length;
var end = message.IndexOf('\'', start);
return end > start ? message[start..end] : "FaceTessellation";
}
private static KernelResult<DisplayTessellationResult> TessellateCore(
BrepBody body,
DisplayTessellationOptions? options,
DisplayTessellationExecutionBudget? executionBudget)
{
if (body is null)
{
return KernelResult<DisplayTessellationResult>.Failure([CreateInvalidArgument("body must be provided.")]);
}
var effectiveOptions = options ?? DisplayTessellationOptions.Default;
var optionDiagnostics = effectiveOptions.Validate();
if (optionDiagnostics.Count > 0)
{
return KernelResult<DisplayTessellationResult>.Failure(optionDiagnostics);
}
var accumulatedDiagnostics = new List<KernelDiagnostic>();
var facePatches = new List<DisplayFaceMeshPatch>();
try
{
var facePhase = BuildPerfTrace.Phase("tessellation.faces");
foreach (var face in body.Topology.Faces.OrderBy(f => f.Id.Value))
{
executionBudget?.ThrowIfExpired("FaceDispatch", face.Id);
var faceResult = ExecuteWithinOptionalBudget(
() => TessellateFace(body, face.Id, effectiveOptions, executionBudget),
executionBudget,
"FaceTessellation",
face.Id,
TryGetSurfaceKind(body, face.Id),
executionBudget is null ? null : executionBudget.Remaining + TimeSpan.FromMilliseconds(250));
if (!faceResult.IsSuccess)
{
return KernelResult<DisplayTessellationResult>.Failure(faceResult.Diagnostics);
}
facePatches.Add(faceResult.Value);
accumulatedDiagnostics.AddRange(faceResult.Diagnostics);
}
facePhase.Dispose();
var edgePolylines = new List<DisplayEdgePolyline>();
var edgePhase = BuildPerfTrace.Phase("tessellation.display-edges");
foreach (var edge in body.Topology.Edges.OrderBy(e => e.Id.Value))
{
executionBudget?.ThrowIfExpired("EdgeDispatch");
var edgeResult = ExecuteWithinOptionalBudget(
() => TessellateEdge(body, edge.Id, effectiveOptions),
executionBudget,
"EdgeTessellation");
if (!edgeResult.IsSuccess)
{
return KernelResult<DisplayTessellationResult>.Failure(edgeResult.Diagnostics);
}
edgePolylines.Add(edgeResult.Value);
accumulatedDiagnostics.AddRange(edgeResult.Diagnostics);
}
edgePhase.Dispose();
return KernelResult<DisplayTessellationResult>.Success(new DisplayTessellationResult(facePatches, edgePolylines), accumulatedDiagnostics);
}
catch (DisplayTessellationTimeoutException ex)
{
return KernelResult<DisplayTessellationResult>.Failure([CreateValidationError(ex.Message, "Viewer.Tessellation.Timeout")]);
}
}
private static KernelResult<T> ExecuteWithinBudget<T>(
Func<KernelResult<T>> action,
DisplayTessellationExecutionBudget executionBudget,
string phase,
FaceId? faceId = null,
SurfaceGeometryKind? surfaceKind = null,
TimeSpan? timeoutOverride = null)
{
try
{
return Task.Run(action)
.WaitAsync(timeoutOverride ?? executionBudget.Remaining)
.GetAwaiter()
.GetResult();
}
catch (TimeoutException)
{
throw new DisplayTessellationTimeoutException(phase, executionBudget.Elapsed, faceId, surfaceKind);
}
}
private static KernelResult<T> ExecuteWithinOptionalBudget<T>(
Func<KernelResult<T>> action,
DisplayTessellationExecutionBudget? executionBudget,
string phase,
FaceId? faceId = null,
SurfaceGeometryKind? surfaceKind = null,
TimeSpan? timeoutOverride = null)
=> executionBudget is null
? action()
: ExecuteWithinBudget(action, executionBudget, phase, faceId, surfaceKind, timeoutOverride);
private static SurfaceGeometryKind? TryGetSurfaceKind(BrepBody body, FaceId faceId)
{
if (!body.TryGetFaceSurfaceGeometry(faceId, out var surface) || surface is null)
{
return null;
}
return surface.Kind;
}
private static KernelResult<DisplayFaceMeshPatch> TessellateFace(BrepBody body, FaceId faceId, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
{
if (!body.TryGetFaceSurfaceGeometry(faceId, out var surface) || surface is null)
{
return KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} is missing bound surface geometry.")]);
}
executionBudget?.ThrowIfExpired("FaceSurfaceDispatch", faceId, surface.Kind);
// Every surface kind is tessellated in its own parameterization, whose normal is the support's, not the
// face's. Projecting the face sense here - once, at the only place face patches are produced - is what makes
// a body's display mesh consistently outward-oriented instead of per-face arbitrary.
var patch = TessellateFaceSupport(body, faceId, surface, options, executionBudget);
return patch.IsSuccess
? KernelResult<DisplayFaceMeshPatch>.Success(DisplayMeshOrientation.ProjectCanonicalOrientation(body, patch.Value), patch.Diagnostics)
: patch;
}
private static KernelResult<DisplayFaceMeshPatch> TessellateFaceSupport(BrepBody body, FaceId faceId, SurfaceGeometry surface, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget)
{
return surface.Kind switch
{
SurfaceGeometryKind.Plane => TessellatePlanarFaceWithSamplingRetry(body, faceId, surface.Plane!.Value, options, executionBudget),
SurfaceGeometryKind.Cylinder => TessellateCylinderFace(body, faceId, surface.Cylinder!.Value, options, executionBudget),
SurfaceGeometryKind.Cone => TessellateConeFace(body, faceId, surface.Cone!.Value, options, executionBudget),
SurfaceGeometryKind.Sphere => TessellateSphereFace(body, faceId, surface.Sphere!.Value, options, executionBudget),
SurfaceGeometryKind.Ellipsoid => TessellateEllipsoidFace(body, faceId, surface.Ellipsoid!, options, executionBudget),
SurfaceGeometryKind.Torus => TessellateTorusFace(body, faceId, surface.Torus!.Value, options, executionBudget),
SurfaceGeometryKind.BSplineSurfaceWithKnots => TessellateBSplineSurfaceFace(body, faceId, surface.BSplineSurfaceWithKnots!, options, executionBudget),
SurfaceGeometryKind.LinearExtrusion when surface.LinearExtrusion!.Value.Directrix.Ellipse3.HasValue
=> TessellateEllipticExtrusionFace(body, faceId, surface.LinearExtrusion.Value, options, executionBudget),
SurfaceGeometryKind.LinearExtrusion when surface.LinearExtrusion!.Value.Directrix.BSpline3 is { } curve
=> TessellateBSplineSurfaceFace(body, faceId, new BSplineSurfaceWithKnots(
curve.Degree, 1,
curve.ControlPoints.Select(p => (IReadOnlyList<Point3D>)new[] { p, p + surface.LinearExtrusion.Value.ExtrusionVector }).ToArray(),
"RULED_SURF", curve.ClosedCurve, false, curve.SelfIntersect,
curve.KnotMultiplicities, [2, 2], curve.KnotValues, [0d, 1d], curve.KnotSpec), options, executionBudget),
_ => KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} has unsupported surface kind '{surface.Kind}'.")]),
};
}
private static KernelResult<DisplayFaceMeshPatch> TessellateEllipticExtrusionFace(BrepBody body, FaceId faceId,
LinearExtrusionSurface surface, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? budget)
{
var ellipse = surface.Directrix.Ellipse3!.Value;
var vector = surface.ExtrusionVector;
var height = vector.Dot(ellipse.Normal.ToVector());
if (double.Abs(height) <= 1e-12 * vector.Length)
return KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} has a degenerate in-plane elliptic extrusion.")]);
var loops = body.GetLoopIds(faceId).Where(id => body.Topology.GetLoop(id).Kind == LoopKind.Edge).ToArray();
if (loops.Length == 0)
return KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} elliptic extrusion requires explicit trim loops.")]);
(double U, double V)? Project(Point3D point)
{
var v = (point - ellipse.Center).Dot(ellipse.Normal.ToVector()) / height;
var radial = point - (ellipse.Center + vector * v);
var u = double.Atan2(radial.Dot(ellipse.YAxis.ToVector()) / ellipse.MinorRadius,
radial.Dot(ellipse.XAxis.ToVector()) / ellipse.MajorRadius);
var residual = point - (ellipse.Evaluate(u) + vector * v);
return residual.Length <= 1e-6 ? (u, v) : null;
}
var trim = TryBuildPeriodicTrimmedSurfaceUvLoops(body, faceId, loops, Project, options, budget, SurfaceGeometryKind.LinearExtrusion);
if (!trim.IsSuccess) return KernelResult<DisplayFaceMeshPatch>.Failure(trim.Diagnostics);
var patch = TrimmedSurfaceTessellator.Tessellate(faceId, trim.Value,
(u, v) => ellipse.Evaluate(u) + vector * v,
(u, _) => Direction3D.Create((ellipse.XAxis.ToVector() * (-ellipse.MajorRadius * double.Sin(u))
+ ellipse.YAxis.ToVector() * (ellipse.MinorRadius * double.Cos(u))).Cross(vector)).ToVector(),
options, double.NegativeInfinity, double.PositiveInfinity, double.NegativeInfinity, double.PositiveInfinity,
CreateValidationWarning, budget, SurfaceGeometryKind.LinearExtrusion);
return patch.IsSuccess && patch.Value.TriangleIndices.Count == 0
? KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} elliptic extrusion trim produced no display triangles.")])
: patch;
}
private static KernelResult<DisplayFaceMeshPatch> TessellatePlanarFaceWithSamplingRetry(BrepBody body, FaceId faceId,
PlaneSurface plane, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? budget)
{
var patch = TessellatePlanarFace(body, faceId, plane, options, budget);
if (options.ChordTolerance <= DisplayTessellationOptions.Default.ChordTolerance
|| patch.IsSuccess && patch.Value.TriangleIndices.Count > 0) return patch;
// Coarse display chords can cross a narrow valid trim. One bounded retry
// samples the same authoritative curves more finely; it does not heal loops.
return TessellatePlanarFace(body, faceId, plane, options with {
ChordTolerance = DisplayTessellationOptions.Default.ChordTolerance
}, budget);
}
private static KernelResult<DisplayFaceMeshPatch> TessellatePlanarFace(BrepBody body, FaceId faceId, PlaneSurface plane, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
{
var loopIds = body.GetLoopIds(faceId)
.Where(loopId => body.Topology.GetLoop(loopId).Kind == LoopKind.Edge)
.ToArray();
if (loopIds.Length == 0)
{
return KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} planar tessellation requires at least one loop.")]);
}
if (loopIds.Length == 1)
{
var simpleLoopPoints = ExecuteWithinOptionalBudget(
() => FlattenPlanarLoop(body, faceId, plane, options, loopIds[0]),
executionBudget,
"PlanarLoopFlattening",
faceId,
SurfaceGeometryKind.Plane);
if (!simpleLoopPoints.IsSuccess)
{
return KernelResult<DisplayFaceMeshPatch>.Failure(simpleLoopPoints.Diagnostics);
}
return ExecuteWithinOptionalBudget(
() => TriangulatePlanarPatch(faceId, plane, simpleLoopPoints.Value),
executionBudget,
"PlanarTriangulation",
faceId,
SurfaceGeometryKind.Plane);
}
var flattenedLoops = new Dictionary<LoopId, IReadOnlyList<Point3D>>();
foreach (var loopId in loopIds.OrderBy(id => id.Value))
{
var flattenedLoop = ExecuteWithinOptionalBudget(
() => FlattenPlanarLoop(body, faceId, plane, options, loopId),
executionBudget,
"PlanarLoopFlattening",
faceId,
SurfaceGeometryKind.Plane);
if (!flattenedLoop.IsSuccess)
{
return KernelResult<DisplayFaceMeshPatch>.Failure(flattenedLoop.Diagnostics);
}
flattenedLoops[loopId] = flattenedLoop.Value;
}
var loopClassification = ExecuteWithinOptionalBudget(
() => KernelResult<IReadOnlyList<PlanarLoopClassification>>.Success(new PlanarDisplayLoopClassifier().Classify(
faceId.Value,
loopIds.OrderBy(id => id.Value).Select(id => (id.Value, flattenedLoops[id])).ToArray())),
executionBudget,
"PlanarLoopClassification",
faceId,
SurfaceGeometryKind.Plane);
if (!loopClassification.IsSuccess)
{
return KernelResult<DisplayFaceMeshPatch>.Failure(loopClassification.Diagnostics);
}
var classifications = loopClassification.Value;
var unsupported = classifications.FirstOrDefault(item => item.Role is PlanarDisplayLoopRole.Degenerate or PlanarDisplayLoopRole.UnsupportedNested or PlanarDisplayLoopRole.Island or PlanarDisplayLoopRole.Unknown);
if (unsupported is not null)
{
var code = unsupported.Role == PlanarDisplayLoopRole.Degenerate
? "Viewer.PlanarTriangulation.DegenerateLoop"
: unsupported.Role is PlanarDisplayLoopRole.UnsupportedNested or PlanarDisplayLoopRole.Island
? "Viewer.PlanarTriangulation.UnsupportedNesting"
: "Viewer.PlanarTriangulation.InvalidLoop";
return KernelResult<DisplayFaceMeshPatch>.Success(
CreateEmptyPlanarPatch(faceId),
[CreateValidationWarning($"Face {faceId.Value} planar loop {unsupported.Loop.LoopId} classified as {unsupported.Role}; reasons=[{string.Join(",", unsupported.Reasons)}].", code)]);
}
var outer = classifications.SingleOrDefault(item => item.Role == PlanarDisplayLoopRole.Outer);
if (outer is null)
{
return KernelResult<DisplayFaceMeshPatch>.Success(
CreateEmptyPlanarPatch(faceId),
[CreateValidationWarning($"Face {faceId.Value} planar multi-loop tessellation could not select a unique outer loop.", "Viewer.PlanarTriangulation.InvalidLoop")]);
}
var outerLoop = outer.Loop.Points3D;
var holes = classifications
.Where(item => item.Role == PlanarDisplayLoopRole.Hole)
.OrderBy(item => item.Loop.LoopId)
.Select(item => item.Loop.Points3D)
.ToArray();
var triangulationResult = ExecuteWithinOptionalBudget(
() =>
{
// The hole-bridging triangulator is super-linear in the number of holes and can exhaust the whole
// display budget on a plate with dozens of holes; earcut handles those directly and cheaply.
if (holes.Length >= ManyHolesEarCutThreshold
&& TryEarCutPlanarLoops(plane, outerLoop, holes, out var manyHolesPoints, out var manyHolesIndices))
{
return KernelResult<(IReadOnlyList<Point3D> Points, IReadOnlyList<int> Indices, PlanarPolygonTriangulationFailure? Failure)>.Success((manyHolesPoints, manyHolesIndices, null));
}
if (!PlanarPolygonTriangulator.TryTriangulateWithHoles(
outerLoop,
holes,
plane.Normal.ToVector(),
out var triangulationPoints,
out var indices,
out var failure))
{
// The primary triangulator declines some long, finely sampled but simple loops; earcut is the second opinion.
if (failure == PlanarPolygonTriangulationFailure.TriangulationFailed
&& TryEarCutPlanarLoops(plane, outerLoop, holes, out var earCutPoints, out var earCutIndices))
{
return KernelResult<(IReadOnlyList<Point3D> Points, IReadOnlyList<int> Indices, PlanarPolygonTriangulationFailure? Failure)>.Success((earCutPoints, earCutIndices, null));
}
return KernelResult<(IReadOnlyList<Point3D> Points, IReadOnlyList<int> Indices, PlanarPolygonTriangulationFailure? Failure)>.Failure([
CreateValidationWarning(
$"Face {faceId.Value} planar multi-loop tessellation could not be resolved ({failure?.ToString() ?? "Unknown"}); skipping face patch to avoid misleading filled geometry.",
PlanarMultiLoopTriangulationSkippedSource)]);
}
return KernelResult<(IReadOnlyList<Point3D> Points, IReadOnlyList<int> Indices, PlanarPolygonTriangulationFailure? Failure)>.Success((triangulationPoints, indices, null));
},
executionBudget,
"PlanarTriangulationWithHoles",
faceId,
SurfaceGeometryKind.Plane);
if (!triangulationResult.IsSuccess)
{
if (triangulationResult.Diagnostics.Any(diagnostic => string.Equals(diagnostic.Source, "Viewer.Tessellation.Timeout", StringComparison.Ordinal)))
{
return KernelResult<DisplayFaceMeshPatch>.Failure(triangulationResult.Diagnostics);
}
return KernelResult<DisplayFaceMeshPatch>.Success(CreateEmptyPlanarPatch(faceId), triangulationResult.Diagnostics.Where(diagnostic => diagnostic.Severity != KernelDiagnosticSeverity.Error));
}
return KernelResult<DisplayFaceMeshPatch>.Success(CreatePlanarPatch(faceId, triangulationResult.Value.Points, plane.Normal.ToVector(), triangulationResult.Value.Indices));
}
private const int ManyHolesEarCutThreshold = 8;
internal static bool TryEarCutPlanarLoops(
PlaneSurface plane,
IReadOnlyList<Point3D> outerLoop,
IReadOnlyList<IReadOnlyList<Point3D>> holes,
out IReadOnlyList<Point3D> points,
out IReadOnlyList<int> indices)
{
points = Array.Empty<Point3D>();
indices = Array.Empty<int>();
var uAxis = plane.UAxis.ToVector();
var vAxis = plane.VAxis.ToVector();
var origin = plane.Origin;
(double X, double Y) Project(Point3D point)
{
var offset = point - origin;
return (offset.Dot(uAxis), offset.Dot(vAxis));
}
var outer2d = outerLoop.Select(Project).ToList();
var holes2d = holes.Select(hole => (IReadOnlyList<(double X, double Y)>)hole.Select(Project).ToList()).ToList();
if (!EarCutTriangulator.TryTriangulate(outer2d, holes2d, out var points2d, out var earCutIndices))
{
return false;
}
var points3d = outerLoop.Concat(holes.SelectMany(hole => hole)).ToArray();
if (points3d.Length != points2d.Count)
{
return false;
}
// Emit every triangle counter-clockwise about the plane normal.
var oriented = new List<int>(earCutIndices.Count);
for (var i = 0; i + 2 < earCutIndices.Count; i += 3)
{
var a = points2d[earCutIndices[i]];
var b = points2d[earCutIndices[i + 1]];
var c = points2d[earCutIndices[i + 2]];
var cross = ((b.X - a.X) * (c.Y - a.Y)) - ((b.Y - a.Y) * (c.X - a.X));
if (cross >= 0d)
{
oriented.Add(earCutIndices[i]);
oriented.Add(earCutIndices[i + 1]);
oriented.Add(earCutIndices[i + 2]);
}
else
{
oriented.Add(earCutIndices[i]);
oriented.Add(earCutIndices[i + 2]);
oriented.Add(earCutIndices[i + 1]);
}
}
points = points3d;
indices = oriented;
return true;
}
private static KernelResult<DisplayFaceMeshPatch> TriangulatePlanarPatch(FaceId faceId, PlaneSurface plane, IReadOnlyList<Point3D> polygonPoints)
{
if (!PlanarPolygonTriangulator.TryTriangulate(polygonPoints, plane.Normal.ToVector(), out var indices, out var failure))
{
return failure switch
{
PlanarPolygonTriangulationFailure.Degenerate => KernelResult<DisplayFaceMeshPatch>.Failure([
CreateInvalidArgument($"Face {faceId.Value} planar loop is degenerate and cannot be triangulated.", "Viewer.Tessellation.PlanarPolygonDegenerate")]),
PlanarPolygonTriangulationFailure.NonSimple => KernelResult<DisplayFaceMeshPatch>.Failure([
CreateNotImplemented($"Face {faceId.Value} planar loop triangulation failed because the polygon is not simple.", "Viewer.Tessellation.PlanarNonConvexTriangulationFailed")]),
_ => KernelResult<DisplayFaceMeshPatch>.Failure([
CreateNotImplemented($"Face {faceId.Value} planar loop triangulation failed.", "Viewer.Tessellation.PlanarNonConvexTriangulationFailed")]),
};
}
return KernelResult<DisplayFaceMeshPatch>.Success(CreatePlanarPatch(faceId, polygonPoints, plane.Normal.ToVector(), indices));
}
private static KernelResult<IReadOnlyList<Point3D>> FlattenPlanarLoop(
BrepBody body,
FaceId faceId,
PlaneSurface plane,
DisplayTessellationOptions options,
LoopId loopId)
{
var coedges = body.GetCoedgeIds(loopId)
.Select(id => body.Topology.GetCoedge(id))
.ToArray();
var polygonPointsResult = BuildFlattenedPlanarLoopPoints(body, coedges, faceId, plane, options);
if (!polygonPointsResult.IsSuccess)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure(polygonPointsResult.Diagnostics);
}
var polygonPoints = polygonPointsResult.Value;
if (polygonPoints.Count < 3)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure([
CreateInvalidArgument($"Face {faceId.Value} planar loop flattening produced fewer than three unique points.", PlanarCurveFlatteningFailedSource)]);
}
return KernelResult<IReadOnlyList<Point3D>>.Success(polygonPoints);
}
private static LoopId SelectPlanarPrimaryLoop(BrepBody body, FaceId faceId, PlaneSurface plane, IReadOnlyList<LoopId> loopIds)
{
if (loopIds.Count <= 1)
{
return loopIds[0];
}
var lineOnlyLoopCandidates = loopIds.Where(loopId => IsAllLine3Loop(body, loopId)).ToArray();
if (TrySelectLargestViablePlanarLoop(body, faceId, plane, lineOnlyLoopCandidates, out var selectedLineLoop))
{
return selectedLineLoop;
}
if (TrySelectLargestViablePlanarLoop(body, faceId, plane, loopIds, out var selectedMixedLoop))
{
return selectedMixedLoop;
}
return loopIds[0];
}
private static bool TrySelectLargestViablePlanarLoop(
BrepBody body,
FaceId faceId,
PlaneSurface plane,
IReadOnlyList<LoopId> candidateLoopIds,
out LoopId bestLoop)
{
bestLoop = default;
var bestArea = double.NegativeInfinity;
foreach (var loopId in candidateLoopIds)
{
var coedges = body.GetCoedgeIds(loopId)
.Select(id => body.Topology.GetCoedge(id))
.ToArray();
var pointsResult = BuildFlattenedPlanarLoopPoints(body, coedges, faceId, plane, DisplayTessellationOptions.Default);
if (!pointsResult.IsSuccess)
{
continue;
}
var polygonPoints = pointsResult.Value;
if (polygonPoints.Count < 3)
{
continue;
}
if (!PlanarPolygonTriangulator.TryTriangulate(polygonPoints, plane.Normal.ToVector(), out _, out _))
{
continue;
}
var area = double.Abs(ComputeSignedPlanarArea(polygonPoints, plane));
if (area > bestArea || (System.Math.Abs(area - bestArea) <= 1e-12d && loopId.Value < bestLoop.Value))
{
bestArea = area;
bestLoop = loopId;
}
}
return bestArea > double.NegativeInfinity;
}
private static bool IsAllLine3Loop(BrepBody body, LoopId loopId)
{
var coedgeIds = body.GetCoedgeIds(loopId);
for (var i = 0; i < coedgeIds.Count; i++)
{
var edgeId = body.Topology.GetCoedge(coedgeIds[i]).EdgeId;
if (body.GetEdgeCurve(edgeId).Kind != CurveGeometryKind.Line3)
{
return false;
}
}
return true;
}
private static double ComputeSignedPlanarArea(IReadOnlyList<Point3D> polygonPoints, PlaneSurface plane)
{
var uAxis = plane.UAxis.ToVector();
var vAxis = plane.VAxis.ToVector();
var area = 0d;
for (var i = 0; i < polygonPoints.Count; i++)
{
var current = polygonPoints[i] - plane.Origin;
var next = polygonPoints[(i + 1) % polygonPoints.Count] - plane.Origin;
var currentU = current.Dot(uAxis);
var currentV = current.Dot(vAxis);
var nextU = next.Dot(uAxis);
var nextV = next.Dot(vAxis);
area += (currentU * nextV) - (nextU * currentV);
}
return area * 0.5d;
}
private static KernelResult<DisplayFaceMeshPatch> TessellatePlanarCircleFace(BrepBody body, FaceId faceId, Coedge coedge, PlaneSurface plane, DisplayTessellationOptions options)
{
var edge = TessellateEdge(body, coedge.EdgeId, options);
if (!edge.IsSuccess)
{
return KernelResult<DisplayFaceMeshPatch>.Failure(edge.Diagnostics);
}
var edgePoints = edge.Value.Points;
if (edgePoints.Count < 4)
{
return KernelResult<DisplayFaceMeshPatch>.Failure([CreateNotImplemented($"Face {faceId.Value} circular planar tessellation requires at least three perimeter samples.")]);
}
var center = new Point3D(
edgePoints.Take(edgePoints.Count - 1).Average(p => p.X),
edgePoints.Take(edgePoints.Count - 1).Average(p => p.Y),
edgePoints.Take(edgePoints.Count - 1).Average(p => p.Z));
var positions = new List<Point3D> { center };
positions.AddRange(edgePoints.Take(edgePoints.Count - 1));
var normal = plane.Normal.ToVector();
if (coedge.IsReversed)
{
normal = -normal;
}
var normals = Enumerable.Repeat(normal, positions.Count).ToArray();
var indices = new List<int>((positions.Count - 2) * 3);
for (var i = 1; i < positions.Count - 1; i++)
{
indices.Add(0);
indices.Add(i);
indices.Add(i + 1);
}
indices.Add(0);
indices.Add(positions.Count - 1);
indices.Add(1);
return KernelResult<DisplayFaceMeshPatch>.Success(new DisplayFaceMeshPatch(faceId, positions, normals, indices));
}
private static KernelResult<DisplayFaceMeshPatch> TessellateCylinderFace(BrepBody body, FaceId faceId, CylinderSurface cylinder, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
{
var loopIds = body.GetLoopIds(faceId)
.Where(loopId => body.Topology.GetLoop(loopId).Kind == LoopKind.Edge)
.ToArray();
var recoveryAllowance = body.GetLoopIds(faceId).SelectMany(body.GetCoedgeIds)
.Select(id => body.GetEdgeCurve(body.Topology.GetCoedge(id).EdgeId).RecoveryProvenance)
.Where(p => p is not null)
.Select(p => double.Min(options.ChordTolerance,
double.Min(p!.RecoveryToleranceMillimetres, p.MeasuredMaxDeviationMillimetres)))
.DefaultIfEmpty(0d).Max();
// Intersecting cylindrical fillet rolls terminate on elliptical miter
// curves. Their axial extent varies with angle; a rectangular UV
// bounding patch protrudes past the retained face at the corners.
var ellipticalBoundary = loopIds.Length == 1 && body.GetCoedgeIds(loopIds[0])
.Any(id => body.GetEdgeCurve(body.Topology.GetCoedge(id).EdgeId).Kind == CurveGeometryKind.Ellipse3);
// A bounded one-loop face can be a helical strip, a toothed skirt, or a
// narrow rectangular sector. Its bounding cylinder is not the trim.
// Prefer the complete bound parameter trace, retaining legacy dispatch
// for closed-circle/seam families without a polygonal pcurve boundary.
if (loopIds.Length == 1 && (ellipticalBoundary || body.GetCoedgeIds(loopIds[0]).Count >= 3
&& body.GetCoedgeIds(loopIds[0]).Select(id => body.Topology.GetCoedge(id).EdgeId).Distinct().Count() == body.GetCoedgeIds(loopIds[0]).Count
&& body.GetCoedgeIds(loopIds[0]).All(id => body.Bindings.TryGetPcurveBinding(id, out var pc) && pc.FaceId == faceId)
|| body.GetCoedgeIds(loopIds[0]).Any(id =>
{
if (!body.Bindings.TryGetPcurveBinding(id, out var binding) || binding.FaceId != faceId)
return false;
var domain = binding.Pcurve.Domain;
var start = binding.Pcurve.Evaluate(domain.Start);
var end = binding.Pcurve.Evaluate(domain.End);
return double.Abs(end.U - start.U) > 1e-8d && double.Abs(end.V - start.V) > 1e-8d;
})))
{
var uvLoops = ellipticalBoundary
? TryBuildPeriodicTrimmedSurfaceUvLoops(body, faceId, loopIds,
point => TryProjectPointToCylinderUv(cylinder, point, recoveryAllowance), options, executionBudget, SurfaceGeometryKind.Cylinder)
: TryBuildTrimmedSurfaceUvLoops(body, faceId, loopIds,
point => TryProjectPointToCylinderUv(cylinder, point, recoveryAllowance), options, executionBudget, SurfaceGeometryKind.Cylinder);
if (!uvLoops.IsSuccess)
return KernelResult<DisplayFaceMeshPatch>.Failure(uvLoops.Diagnostics);
return TrimmedSurfaceTessellator.Tessellate(faceId, uvLoops.Value,
(u, v) => cylinder.Evaluate(u, v),
(u, _) => cylinder.Normal(u).ToVector(), options,
double.NegativeInfinity, double.PositiveInfinity,
double.NegativeInfinity, double.PositiveInfinity,
CreateValidationWarning, executionBudget, SurfaceGeometryKind.Cylinder);
}
if (loopIds.Length == 2
&& TryResolveDualSingleCoedgeClosedCircleCylinderTrimPatch(body, faceId, cylinder, loopIds, cylinder.Axis.ToVector(), 1e-8d).IsSuccess)
{
// A seamless cylindrical band (hole wall or boss) is bounded by two full circles. In UV those are two
// zero-area lines, not an outer loop plus a hole, so the generic multi-loop trim path derives a degenerate
// domain and drops the face. The dedicated dual-circle resolution knows the band is the strip between them.
return TessellateLegacyCylinderFace(body, faceId, cylinder, options);
}
if (loopIds.Length > 1)
{
var uvLoopsResult = TryBuildPeriodicTrimmedSurfaceUvLoops(body, faceId, loopIds, point => TryProjectPointToCylinderUv(cylinder, point, recoveryAllowance), options, executionBudget, SurfaceGeometryKind.Cylinder);
if (!uvLoopsResult.IsSuccess)
{
return KernelResult<DisplayFaceMeshPatch>.Success(
CreateEmptyPlanarPatch(faceId),
[CreateValidationWarning(
$"Face {faceId.Value} cylinder trim evaluation failed; skipping face patch to avoid misleading untrimmed geometry. Cause: {uvLoopsResult.Diagnostics.FirstOrDefault()?.Message}",
TrimEvaluationFailedSource)]);
}
return TrimmedSurfaceTessellator.Tessellate(
faceId,
StitchWrappingLoops(uvLoopsResult.Value),
(u, v) => cylinder.Evaluate(u, v),
(u, _) => cylinder.Normal(u).ToVector(),
options,
double.NegativeInfinity,
double.PositiveInfinity,
double.NegativeInfinity,
double.PositiveInfinity,
CreateValidationWarning,
executionBudget,
SurfaceGeometryKind.Cylinder);
}
return TessellateLegacyCylinderFace(body, faceId, cylinder, options);
}
private static KernelResult<DisplayFaceMeshPatch> TessellateConeFace(BrepBody body, FaceId faceId, ConeSurface cone, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
{
// A cone-apex VERTEX_LOOP is a preserved zero-dimensional boundary, not an
// area-trim curve. Only edge loops participate in UV polygon tessellation.
var loopIds = body.GetLoopIds(faceId)
.Where(loopId => body.Topology.GetLoop(loopId).Kind == LoopKind.Edge)
.ToArray();
if (TryResolveFullPeriodicConeBetweenCircularTrimLoops(body, faceId, loopIds, cone, options, out var fullFrustumPatch, out var fullFrustumDiagnostics))
{
return KernelResult<DisplayFaceMeshPatch>.Success(fullFrustumPatch, fullFrustumDiagnostics);
}
if (loopIds.Length > 0)
{
var uvLoopsResult = TryBuildPeriodicTrimmedSurfaceUvLoops(body, faceId, loopIds, point => TryProjectPointToConeUv(cone, point), options, executionBudget, SurfaceGeometryKind.Cone);
if (!uvLoopsResult.IsSuccess)
{
return KernelResult<DisplayFaceMeshPatch>.Success(
CreateEmptyPlanarPatch(faceId),
[CreateValidationWarning(
$"Face {faceId.Value} cone trim evaluation failed; skipping face patch to avoid misleading untrimmed geometry. Cause: {uvLoopsResult.Diagnostics.FirstOrDefault()?.Message}",
TrimEvaluationFailedSource)]);
}
if (loopIds.Length == 1 && UsesFullPeriodicAngularSpan(uvLoopsResult.Value) && UsesSimpleAnalyticRevolvedLoopTopology(body, loopIds[0]))
{
return TessellateLegacyConeFace(body, faceId, cone, options);
}
return TrimmedSurfaceTessellator.Tessellate(
faceId,
StitchWrappingLoops(uvLoopsResult.Value),
(u, v) => cone.Evaluate(u, v),
(u, _) => cone.Normal(u).ToVector(),
options,
double.NegativeInfinity,
double.PositiveInfinity,
double.NegativeInfinity,
double.PositiveInfinity,
CreateValidationWarning,
executionBudget,
SurfaceGeometryKind.Cone);
}
return TessellateLegacyConeFace(body, faceId, cone, options);
}
/// <summary>
/// Resolves the deliberately narrow full-frustum cone family used by hollow frusta:
/// two separate closed circular trim loops are the lower and upper generator bounds,
/// not an outer loop plus a hole. The generic UV trim path represents each full
/// circle as a periodic ring; treating the second ring as a hole cancels the entire
/// periodic domain and used to yield zero triangles for both material cone faces.
/// </summary>
private static bool TryResolveFullPeriodicConeBetweenCircularTrimLoops(
BrepBody body,
FaceId faceId,
IReadOnlyList<LoopId> loopIds,
ConeSurface cone,
DisplayTessellationOptions options,
out DisplayFaceMeshPatch patch,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
patch = default!;
diagnostics = [];
if (loopIds.Count != 2)
{
return false;
}
var trimLevels = new List<(double Axial, double Radius)>();
var tolerance = System.Math.Max(1e-6d, options.ChordTolerance * 1e-3d);
var axis = cone.Axis.ToVector();
foreach (var loopId in loopIds.OrderBy(id => id.Value))
{
var coedgeIds = body.GetCoedgeIds(loopId);
if (coedgeIds.Count != 1)
{
return false;
}
var coedge = body.Topology.GetCoedge(coedgeIds[0]);
var edge = body.Topology.GetEdge(coedge.EdgeId);
if (edge.StartVertexId != edge.EndVertexId
|| !body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var edgeBinding)
|| edgeBinding.TrimInterval is not { } trim
|| System.Math.Abs((trim.End - trim.Start) - (2d * double.Pi)) > 1e-5d
|| body.GetEdgeCurve(coedge.EdgeId).Circle3 is not { } circle)
{
return false;
}
// A full circular trim must be coaxial with the support and lie on its
// equation. Sampling four quadrants makes the authority explicit: these
// levels come from BRep trim topology, never fixture dimensions.
if (System.Math.Abs(circle.Normal.ToVector().Dot(axis)) < (1d - 1e-6d))
{
return false;
}
var centerOffset = circle.Center - cone.Apex;
var axial = centerOffset.Dot(axis);
var axisResidual = (centerOffset - (axis * axial)).Length;
var expectedRadius = axial * double.Tan(cone.SemiAngleRadians);
var supportTolerance = System.Math.Max(tolerance, System.Math.Max(circle.Radius, expectedRadius) * 1e-6d);
if (axial <= supportTolerance
|| axisResidual > supportTolerance
|| System.Math.Abs(circle.Radius - expectedRadius) > supportTolerance)
{
return false;
}
for (var sample = 0; sample < 4; sample++)
{
var point = circle.Evaluate(sample * (double.Pi / 2d));
if (TryProjectPointToConeUv(cone, point) is null)
{
return false;
}
}
trimLevels.Add((axial, circle.Radius));
}
var ordered = trimLevels.OrderBy(level => level.Axial).ToArray();
if (ordered[1].Axial - ordered[0].Axial <= tolerance)
{
return false;
}
var angularSegments = CalculateSegmentCount(2d * double.Pi, ordered.Max(level => level.Radius), options);
// Cone generators are straight and the normal is constant along them: one row of quads is exact.
var axialSegments = 1;
patch = CreatePeriodicGridPatch(
faceId,
angularSegments,
axialSegments,
(u, v) => cone.Evaluate(u, v),
(u, _) => cone.Normal(u).ToVector(),
ordered[0].Axial,
ordered[1].Axial);
diagnostics = [new KernelDiagnostic(
KernelDiagnosticCode.Unknown,
KernelDiagnosticSeverity.Info,
$"Face {faceId.Value} tessellated as a topology-derived full-period cone strip: angularSegments={angularSegments}, generatorSegments={axialSegments}, trimAxial=[{ordered[0].Axial:R},{ordered[1].Axial:R}].",
"Viewer.Cone.FullPeriodicCircularTrims")];
return true;
}
private static KernelResult<DisplayFaceMeshPatch> TessellateLegacyCylinderFace(BrepBody body, FaceId faceId, CylinderSurface cylinder, DisplayTessellationOptions options)
{
var trimPatch = TryResolveCylinderTrimPatch(body, faceId, cylinder);
if (!trimPatch.IsSuccess)
{
return KernelResult<DisplayFaceMeshPatch>.Failure(trimPatch.Diagnostics);
}
var angularSpan = trimPatch.Value.UEnd - trimPatch.Value.UStart;
var axialSpan = trimPatch.Value.VEnd - trimPatch.Value.VStart;
var nearFullPeriodicSpan = (2d * double.Pi) - 0.25d;
if (angularSpan >= nearFullPeriodicSpan)
{
var periodicParameters = GetRevolvedFaceParameters(
body,
faceId,
options,
radiusHint: cylinder.Radius,
allowThreeCoedgeConeTopology: false,
axialParameterFromPoint: point => (point - cylinder.Origin).Dot(cylinder.Axis.ToVector()));
if (periodicParameters.IsSuccess)
{
// Cylinder generators are straight: axial subdivision adds triangles but no accuracy.
return KernelResult<DisplayFaceMeshPatch>.Success(CreatePeriodicGridPatch(
faceId,
periodicParameters.Value.AngularSegments,
1,
(u, v) => cylinder.Evaluate(u, v),
(u, _) => cylinder.Normal(u).ToVector(),
periodicParameters.Value.VStart,
periodicParameters.Value.VEnd),
periodicParameters.Diagnostics);
}
}
var angularSegments = CalculateSegmentCount(angularSpan, System.Math.Max(1e-6d, cylinder.Radius), options);
const int axialSegments = 1;
return KernelResult<DisplayFaceMeshPatch>.Success(CreateBoundedGridPatch(
faceId,
angularSegments,
axialSegments,
(u, v) => cylinder.Evaluate(u, v),
(u, _) => cylinder.Normal(u).ToVector(),
trimPatch.Value.UStart,
trimPatch.Value.UEnd,
trimPatch.Value.VStart,
trimPatch.Value.VEnd),
trimPatch.Diagnostics);
}
private static KernelResult<DisplayFaceMeshPatch> TessellateLegacyConeFace(BrepBody body, FaceId faceId, ConeSurface cone, DisplayTessellationOptions options)
{
var parameters = GetRevolvedFaceParameters(
body,
faceId,
options,
radiusHint: 1d,
allowThreeCoedgeConeTopology: true,
axialParameterFromPoint: cone.AxialParameterFromPoint);
if (!parameters.IsSuccess)
{
return KernelResult<DisplayFaceMeshPatch>.Failure(parameters.Diagnostics);
}
return KernelResult<DisplayFaceMeshPatch>.Success(CreatePeriodicGridPatch(
faceId,
parameters.Value.AngularSegments,
1,
(u, v) => cone.Evaluate(u, v),
(u, _) => cone.Normal(u).ToVector(),
parameters.Value.VStart,
parameters.Value.VEnd));
}
private static bool UsesSimpleAnalyticRevolvedLoopTopology(BrepBody body, LoopId loopId)
{
var coedges = body.GetCoedgeIds(loopId).Select(id => body.Topology.GetCoedge(id)).ToArray();
if (coedges.Length == 0 || coedges.Length > 4)
{
return false;
}
return coedges
.Select(coedge => body.GetEdgeCurve(coedge.EdgeId).Kind)
.All(kind => kind is CurveGeometryKind.Line3 or CurveGeometryKind.Circle3);
}
private static bool UsesFullPeriodicAngularSpan(IReadOnlyList<IReadOnlyList<(double U, double V)>> uvLoops)
{
if (uvLoops.Count == 0)
{
return false;
}
var outerLoop = uvLoops
.Select(NormalizePeriodicLoop)
.OrderByDescending(loop => System.Math.Abs(ComputePeriodicLoopSignedArea(loop)))
.First();
if (outerLoop.Count == 0)
{
return false;
}
var span = outerLoop.Max(point => point.U) - outerLoop.Min(point => point.U);
return span >= ((2d * double.Pi) - 0.25d);
}
private static List<(double U, double V)> NormalizePeriodicLoop(IReadOnlyList<(double U, double V)> loop)
{
var normalized = new List<(double U, double V)>(loop.Count);
foreach (var point in loop)
{
if (normalized.Count == 0 || System.Math.Abs(normalized[^1].U - point.U) > 1e-9d || System.Math.Abs(normalized[^1].V - point.V) > 1e-9d)
{
normalized.Add(point);
}
}
if (normalized.Count > 1
&& System.Math.Abs(normalized[0].U - normalized[^1].U) <= 1e-9d
&& System.Math.Abs(normalized[0].V - normalized[^1].V) <= 1e-9d)
{
normalized.RemoveAt(normalized.Count - 1);
}
return normalized;
}
private static double ComputePeriodicLoopSignedArea(IReadOnlyList<(double U, double V)> loop)
{
var area = 0d;
for (var i = 0; i < loop.Count; i++)
{
var current = loop[i];
var next = loop[(i + 1) % loop.Count];
area += (current.U * next.V) - (next.U * current.V);
}
return area * 0.5d;
}
private static KernelResult<DisplayFaceMeshPatch> TessellateBSplineSurfaceFace(BrepBody body, FaceId faceId, BSplineSurfaceWithKnots surface, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
{
executionBudget?.ThrowIfExpired("BSplineSurface.Start", faceId, SurfaceGeometryKind.BSplineSurfaceWithKnots);
var loopIds = body.GetLoopIds(faceId)
.Where(loopId => body.Topology.GetLoop(loopId).Kind == LoopKind.Edge)
.ToArray();
if (loopIds.Length == 0)
{
return KernelResult<DisplayFaceMeshPatch>.Success(CreateBoundedGridPatch(
faceId,
options.MinimumSegments,
options.MinimumSegments,
(u, v) => surface.Evaluate(u, v),
(u, v) => EvaluateBSplineNormal(surface, u, v),
surface.DomainStartU,
surface.DomainEndU,
surface.DomainStartV,
surface.DomainEndV));
}
var projector = new BSplineUvProjector(surface);
var uvLoopsResult = BuildSplineDisplayTrim(body, faceId, loopIds, projector, options, executionBudget);
if (!uvLoopsResult.IsSuccess)
{
return KernelResult<DisplayFaceMeshPatch>.Success(
CreateEmptyPlanarPatch(faceId),
[CreateValidationWarning(
$"Face {faceId.Value} BSpline trim evaluation failed ({string.Join(" | ", uvLoopsResult.Diagnostics.Select(diagnostic => diagnostic.Message))}); projection residual={projector.LastResidual:R} mm, candidate UV={projector.LastCandidate}, native domain=[{surface.DomainStartU:R},{surface.DomainEndU:R}]x[{surface.DomainStartV:R},{surface.DomainEndV:R}]; skipping face patch to avoid misleading untrimmed geometry.",
TrimEvaluationFailedSource)]);
}
return TrimmedSurfaceTessellator.Tessellate(
faceId,
NormalizeClosedSplineLoops(surface, uvLoopsResult.Value),
(u, v) => surface.Evaluate(u, v),
(u, v) => EvaluateBSplineNormal(surface, u, v),
options,
surface.DomainStartU,
surface.DomainEndU,
surface.DomainStartV,
surface.DomainEndV,
CreateValidationWarning,
executionBudget,
SurfaceGeometryKind.BSplineSurfaceWithKnots,
splineSupport: surface);
}
/// <summary>Display projection reuses the qualified pcurve inverter, with a separate display budget.</summary>
internal static KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>> InspectSplineTrim(BrepBody body, FaceId faceId)
{
body.TryGetFaceSurface(faceId, out var surface);
var support = surface?.BSplineSurfaceWithKnots
?? throw new ArgumentException("Face is not spline-supported.", nameof(faceId));
var input = BuildSplineDisplayTrim(body, faceId,
body.GetLoopIds(faceId).Where(id => body.Topology.GetLoop(id).Kind == LoopKind.Edge).ToArray(),
new BSplineUvProjector(support), DisplayTessellationOptions.ForViewport(body), null);
return input.IsSuccess ? KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Success(
NormalizeClosedSplineLoops(support, input.Value)) : input;
}
private static KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>> BuildSplineDisplayTrim(
BrepBody body, FaceId faceId, IReadOnlyList<LoopId> loopIds, BSplineUvProjector projector,
DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget)
{
var input = TryBuildTrimmedSurfaceUvLoops(body, faceId, loopIds, projector.Project,
options, executionBudget, SurfaceGeometryKind.BSplineSurfaceWithKnots);
if (!input.IsSuccess || !input.Value.Any(IsCollapsedSplineLoop)
|| !loopIds.SelectMany(body.GetCoedgeIds).All(id =>
body.Bindings.TryGetPcurveBinding(id, out var binding)
&& binding.Qualification?.Origin == PcurveBindingOrigin.RecoveredSpline)) return input;
// A recovered parameter trace may flatten a feature smaller than its lift
// budget. Display samples the actual bounded edges onto the existing support;
// retained source pcurves, BRep bindings and export remain unchanged.
return TryBuildTrimmedSurfaceUvLoops(body, faceId, loopIds, projector.Project, options with {
MinimumSegments = System.Math.Min(options.MaximumSegments, System.Math.Max(64, options.MinimumSegments))
}, executionBudget, SurfaceGeometryKind.BSplineSurfaceWithKnots, preferBoundPcurves: false);
}
private static bool IsCollapsedSplineLoop(IReadOnlyList<(double U, double V)> loop)
{
if (loop.Count < 3) return true;
var width = loop.Max(p => p.U) - loop.Min(p => p.U);
var height = loop.Max(p => p.V) - loop.Min(p => p.V);
var origin = loop[0];
var twiceArea = 0d;
for (var i = 0; i < loop.Count; i++)
{
var a = loop[i]; var b = loop[(i + 1) % loop.Count];
twiceArea += (a.U - origin.U) * (b.V - origin.V) - (b.U - origin.U) * (a.V - origin.V);
}
return width <= 0d || height <= 0d || double.Abs(twiceArea) <= width * height * 1e-10d;
}
internal static IReadOnlyList<IReadOnlyList<(double U, double V)>> NormalizeClosedSplineLoops(
BSplineSurfaceWithKnots surface, IReadOnlyList<IReadOnlyList<(double U, double V)>> loops)
{
return loops.Select(loop =>
{
var points = loop.ToArray();
Normalize(surface.UClosed, surface.DomainStartU, surface.DomainEndU, true);
Normalize(surface.VClosed, surface.DomainStartV, surface.DomainEndV, false);
return (IReadOnlyList<(double U, double V)>)points;
void Normalize(bool closed, double start, double end, bool alongU)
{
if (!closed || points.Length == 0) return;
var period = end - start;
for (var i = 1; i < points.Length; i++)
{
var p = points[i];
points[i] = alongU
? (BrepPcurveRecovery.UnwrapNear(p.U, points[i - 1].U, period), p.V)
: (p.U, BrepPcurveRecovery.UnwrapNear(p.V, points[i - 1].V, period));
}
var minimum = points.Min(p => alongU ? p.U : p.V);
var shift = double.Floor((minimum - start + period * 1e-8d) / period) * period;
for (var i = 0; i < points.Length; i++)
points[i] = alongU ? (points[i].U - shift, points[i].V) : (points[i].U, points[i].V - shift);
}
}).ToArray();
}
private sealed class BSplineUvProjector
{
private readonly BSplineSurfaceWithKnots _surface;
private readonly double _tolerance;
private SurfaceParameterPoint? _last;
public double LastResidual { get; private set; }
public (double U, double V) LastCandidate { get; private set; }
public BSplineUvProjector(BSplineSurfaceWithKnots surface)
{
_surface = surface;
_tolerance = ComputeBSplineProjectionTolerance(surface);
}
public (double U, double V)? Project(Point3D point)
{
var result = BrepPcurveRecovery.ProjectSplinePoint(_surface, point, _last, _tolerance);
if (!result.Success && _last is not null)
result = BrepPcurveRecovery.ProjectSplinePoint(_surface, point, null, _tolerance);
LastResidual = result.Residual;
LastCandidate = (result.Uv.U, result.Uv.V);
if (!result.Success) return null;
_last = result.Uv;
return LastCandidate;
}
}
private static KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>> TryBuildDoublyPeriodicTrimmedSurfaceUvLoops(
BrepBody body,
FaceId faceId,
IReadOnlyList<LoopId> loopIds,
Func<Point3D, (double U, double V)?> projectPointToUv,
DisplayTessellationOptions options,
DisplayTessellationExecutionBudget? executionBudget = null,
SurfaceGeometryKind? surfaceKind = null)
{
var uvLoops = new List<IReadOnlyList<(double U, double V)>>(loopIds.Count);
foreach (var loopId in loopIds.OrderBy(id => id.Value))
{
executionBudget?.ThrowIfExpired("DoublyPeriodicTrimLoopDispatch", faceId, surfaceKind);
var uvLoop = TryBuildDoublyPeriodicTrimmedSurfaceUvLoop(body, faceId, loopId, projectPointToUv, options, executionBudget, surfaceKind);
if (!uvLoop.IsSuccess)
{
return KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Failure(uvLoop.Diagnostics);
}
uvLoops.Add(uvLoop.Value);
}
return KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Success(uvLoops);
}
private static KernelResult<IReadOnlyList<(double U, double V)>> TryBuildDoublyPeriodicTrimmedSurfaceUvLoop(
BrepBody body,
FaceId faceId,
LoopId loopId,
Func<Point3D, (double U, double V)?> projectPointToUv,
DisplayTessellationOptions options,
DisplayTessellationExecutionBudget? executionBudget = null,
SurfaceGeometryKind? surfaceKind = null)
{
var coedges = body.GetCoedgeIds(loopId).Select(id => body.Topology.GetCoedge(id)).ToArray();
if (coedges.Length < 1)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
CreateNotImplemented(
$"Face {faceId.Value} periodic trim loop must contain at least one coedge.",
TrimEvaluationFailedSource)]);
}
var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
if (!vertexPointsResult.IsSuccess)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(vertexPointsResult.Diagnostics);
}
var uvPoints = new List<(double U, double V)>();
double? previousWrappedU = null;
double? previousWrappedV = null;
double currentUOffset = 0d;
double currentVOffset = 0d;
foreach (var coedge in coedges)
{
executionBudget?.ThrowIfExpired("DoublyPeriodicTrimLoopSampling", faceId, surfaceKind);
var sampledCurve = TrySampleCoedgeForTrimEvaluation(body, faceId, coedge, vertexPointsResult.Value, options, executionBudget, surfaceKind);
if (!sampledCurve.IsSuccess)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(sampledCurve.Diagnostics);
}
foreach (var point in sampledCurve.Value)
{
var uv = projectPointToUv(point);
if (!uv.HasValue)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
CreateNotImplemented(
$"Face {faceId.Value} periodic trim tessellation could not project loop samples into the native torus parameter domain.",
TrimEvaluationFailedSource)]);
}
var unwrapResult = TryUnwrapDoublyPeriodicUvPoint(
uvPoints,
uv.Value,
ref previousWrappedU,
ref currentUOffset,
ref previousWrappedV,
ref currentVOffset,
faceId);
if (!unwrapResult.IsSuccess)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(unwrapResult.Diagnostics);
}
}
}
if (uvPoints.Count > 1 && UvPointsAlmostEqual(uvPoints[0], uvPoints[^1]))
{
uvPoints.RemoveAt(uvPoints.Count - 1);
}
return KernelResult<IReadOnlyList<(double U, double V)>>.Success(uvPoints);
}
/// <summary>
/// Two loops that each run once round a periodic surface bound the band between them. In the unrolled chart each is
/// an open polyline one period long, so treated as polygons they enclose only what lies between each polyline and
/// its own closing chord: a wavy loop (a slot cut into a bore's end) keeps only its notch and loses the band. The
/// band is one polygon: one loop over a period from a common seam, then the other back along it.
/// </summary>
internal static IReadOnlyList<IReadOnlyList<(double U, double V)>> StitchWrappingLoops(IReadOnlyList<IReadOnlyList<(double U, double V)>> loops)
{
const double period = 2d * double.Pi;
static double Turn(IReadOnlyList<(double U, double V)> loop) => loop.Count < 2 ? 0d : loop[^1].U - loop[0].U;
var wrapping = Enumerable.Range(0, loops.Count)
.Where(i => loops[i].Count >= 2 && double.Abs(double.Abs(Turn(loops[i])) - period) < 1e-3d)
.ToArray();
if (wrapping.Length != 2) return loops;
// A period of each loop running +u from where it first crosses the seam; the seam avoids every vertex, so each
// crossing is a proper one.
var seam = loops[wrapping[0]][0].U + 1e-3d * double.Pi;
List<(double U, double V)>? Period(IReadOnlyList<(double U, double V)> loop)
{
var forward = Turn(loop) > 0d ? loop.ToList() : loop.Reverse().ToList();
var shift = double.Floor((seam - forward[0].U) / period) * period;
var extended = new List<(double U, double V)>();
for (var k = 0; k < 3; k++) extended.AddRange(forward.Skip(k == 0 ? 0 : 1).Select(p => (U: p.U + shift + k * period, p.V)));
for (var i = 0; i + 1 < extended.Count; i++)
{
var (a, b) = (extended[i], extended[i + 1]);
if (!(a.U <= seam && b.U > seam)) continue;
var t = (seam - a.U) / (b.U - a.U);
(double U, double V) start = (seam, a.V + t * (b.V - a.V));
var result = new List<(double U, double V)> { start };
for (var j = i + 1; j + 1 < extended.Count; j++)
{
var (c, d) = (extended[j], extended[j + 1]);
result.Add(c);
if (c.U < seam + period && d.U >= seam + period)
{
var s = (seam + period - c.U) / (d.U - c.U);
result.Add((seam + period, c.V + s * (d.V - c.V)));
return result;
}
}
return null;
}
return null;
}
var lower = Period(loops[wrapping[0]]);
var upper = Period(loops[wrapping[1]]);
if (lower is null || upper is null) return loops;
upper.Reverse();
var band = lower.Concat(upper).ToList();
var stitched = new List<IReadOnlyList<(double U, double V)>> { band };
stitched.AddRange(Enumerable.Range(0, loops.Count).Where(i => !wrapping.Contains(i)).Select(i => loops[i]));
return stitched;
}
private static KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>> TryBuildPeriodicTrimmedSurfaceUvLoops(
BrepBody body,
FaceId faceId,
IReadOnlyList<LoopId> loopIds,
Func<Point3D, (double U, double V)?> projectPointToUv,
DisplayTessellationOptions options,
DisplayTessellationExecutionBudget? executionBudget = null,
SurfaceGeometryKind? surfaceKind = null)
{
var uvLoops = new List<IReadOnlyList<(double U, double V)>>(loopIds.Count);
foreach (var loopId in loopIds.OrderBy(id => id.Value))
{
executionBudget?.ThrowIfExpired("PeriodicTrimLoopDispatch", faceId, surfaceKind);
var uvLoop = TryBuildPeriodicTrimmedSurfaceUvLoop(body, faceId, loopId, projectPointToUv, options, executionBudget, surfaceKind);
if (!uvLoop.IsSuccess)
{
return KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Failure(uvLoop.Diagnostics);
}
uvLoops.Add(uvLoop.Value);
}
return KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Success(uvLoops);
}
private static KernelResult<IReadOnlyList<(double U, double V)>> TryBuildPeriodicTrimmedSurfaceUvLoop(
BrepBody body,
FaceId faceId,
LoopId loopId,
Func<Point3D, (double U, double V)?> projectPointToUv,
DisplayTessellationOptions options,
DisplayTessellationExecutionBudget? executionBudget = null,
SurfaceGeometryKind? surfaceKind = null)
{
var coedges = body.GetCoedgeIds(loopId).Select(id => body.Topology.GetCoedge(id)).ToArray();
if (coedges.Length < 1)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
CreateNotImplemented(
$"Face {faceId.Value} periodic trim loop must contain at least one coedge.",
TrimEvaluationFailedSource)]);
}
var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
if (!vertexPointsResult.IsSuccess)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(vertexPointsResult.Diagnostics);
}
var uvPoints = new List<(double U, double V)>();
double? previousWrappedU = null;
double currentUOffset = 0d;
var wrappedSpanTolerance = double.Pi + 1e-6d;
foreach (var coedge in coedges)
{
executionBudget?.ThrowIfExpired("PeriodicTrimLoopSampling", faceId, surfaceKind);
var sampledCurve = TrySampleCoedgeForTrimEvaluation(body, faceId, coedge, vertexPointsResult.Value, options, executionBudget, surfaceKind);
if (!sampledCurve.IsSuccess)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(sampledCurve.Diagnostics);
}
foreach (var point in sampledCurve.Value)
{
var uv = projectPointToUv(point);
if (!uv.HasValue)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
CreateNotImplemented(
$"Face {faceId.Value} periodic trim tessellation could not project loop samples into the native parameter domain.",
TrimEvaluationFailedSource)]);
}
var wrappedU = uv.Value.U;
if (previousWrappedU.HasValue)
{
var delta = wrappedU - previousWrappedU.Value;
if (delta > double.Pi)
{
currentUOffset -= 2d * double.Pi;
}
else if (delta < -double.Pi)
{
currentUOffset += 2d * double.Pi;
}
var adjustedDelta = (wrappedU + currentUOffset) - uvPoints[^1].U;
if (double.Abs(adjustedDelta) > wrappedSpanTolerance)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
CreateNotImplemented(
$"Face {faceId.Value} periodic trim loop crossed the angular seam ambiguously and could not be normalized deterministically.",
TrimEvaluationFailedSource)]);
}
}
AppendUniqueUvPoint(uvPoints, (wrappedU + currentUOffset, uv.Value.V));
previousWrappedU = wrappedU;
}
}
if (uvPoints.Count > 1 && UvPointsAlmostEqual(uvPoints[0], uvPoints[^1]))
{
uvPoints.RemoveAt(uvPoints.Count - 1);
}
return KernelResult<IReadOnlyList<(double U, double V)>>.Success(uvPoints);
}
private static KernelResult<bool> TryUnwrapDoublyPeriodicUvPoint(
List<(double U, double V)> uvPoints,
(double U, double V) wrappedUv,
ref double? previousWrappedU,
ref double currentUOffset,
ref double? previousWrappedV,
ref double currentVOffset,
FaceId faceId)
{
var unwrappedUResult = TryUnwrapPeriodicCoordinate(wrappedUv.U, uvPoints, isUCoordinate: true, ref previousWrappedU, ref currentUOffset, faceId);
if (!unwrappedUResult.IsSuccess)
{
return KernelResult<bool>.Failure(unwrappedUResult.Diagnostics);
}
var unwrappedVResult = TryUnwrapPeriodicCoordinate(wrappedUv.V, uvPoints, isUCoordinate: false, ref previousWrappedV, ref currentVOffset, faceId);
if (!unwrappedVResult.IsSuccess)
{
return KernelResult<bool>.Failure(unwrappedVResult.Diagnostics);
}
AppendUniqueUvPoint(uvPoints, (unwrappedUResult.Value, unwrappedVResult.Value));
return KernelResult<bool>.Success(true);
}
private static KernelResult<double> TryUnwrapPeriodicCoordinate(
double wrappedValue,
IReadOnlyList<(double U, double V)> uvPoints,
bool isUCoordinate,
ref double? previousWrappedValue,
ref double currentOffset,
FaceId faceId)
{
var wrappedSpanTolerance = double.Pi + 1e-6d;
if (previousWrappedValue.HasValue)
{
var delta = wrappedValue - previousWrappedValue.Value;
if (delta > double.Pi)
{
currentOffset -= 2d * double.Pi;
}
else if (delta < -double.Pi)
{
currentOffset += 2d * double.Pi;
}
if (uvPoints.Count > 0)
{
var adjustedValue = wrappedValue + currentOffset;
var previousValue = isUCoordinate ? uvPoints[^1].U : uvPoints[^1].V;
if (double.Abs(adjustedValue - previousValue) > wrappedSpanTolerance)
{
var coordinateName = isUCoordinate ? "major" : "minor";
return KernelResult<double>.Failure([
CreateNotImplemented(
$"Face {faceId.Value} torus trim loop crossed the {coordinateName} angular seam ambiguously and could not be normalized deterministically.",
TrimEvaluationFailedSource)]);
}
}
}
previousWrappedValue = wrappedValue;
return KernelResult<double>.Success(wrappedValue + currentOffset);
}
/// <summary>
/// Recognizes a torus face bounded by exactly two single-edge full-circle loops that are coaxial with the torus
/// (constant minor angle v). The band between them is the shorter tube arc; a face wider than half the tube is
/// ambiguous without orientation analysis and is left to the generic path.
/// </summary>
private static bool TryResolveCoaxialCirclePairTorusBand(BrepBody body, TorusSurface torus, IReadOnlyList<LoopId> loopIds, out double vStart, out double vEnd)
{
vStart = 0d;
vEnd = 0d;
var angles = new double[2];
for (var i = 0; i < 2; i++)
{
var coedgeIds = body.GetCoedgeIds(loopIds[i]);
if (coedgeIds.Count != 1)
{
return false;
}
var edge = body.Topology.GetCoedge(coedgeIds[0]).EdgeId;
var curve = body.GetEdgeCurve(edge);
if (curve.Kind != CurveGeometryKind.Circle3 || curve.Circle3 is not { } circle)
{
return false;
}
var axis = torus.Axis.ToVector();
var offset = circle.Center - torus.Center;
var alongAxis = offset.Dot(axis);
var offAxis = (offset - (axis * alongAxis)).Length;
if (offAxis > 1e-6d || double.Abs(circle.Normal.ToVector().Dot(axis)) < 1d - 1e-9d)
{
return false;
}
angles[i] = TorusMinorAngleOf(torus, circle.Evaluate(0d));
}
var delta = angles[1] - angles[0];
delta -= 2d * double.Pi * double.Round(delta / (2d * double.Pi));
if (double.Abs(delta) < 1e-9d || double.Abs(delta) > double.Pi - 1e-6d)
{
return false;
}
vStart = delta > 0d ? angles[0] : angles[1];
vEnd = vStart + double.Abs(delta);
return true;
}
private static (double U, double V)? TryProjectPointToTorusUv(TorusSurface torus, Point3D point)
{
var axis = torus.Axis.ToVector();
var xAxis = torus.XAxis.ToVector();
var yAxis = torus.YAxis.ToVector();
var offset = point - torus.Center;
var axial = offset.Dot(axis);
var planar = offset - (axis * axial);
var planarLength = planar.Length;
if (!double.IsFinite(planarLength))
{
return null;
}
// A bounded horn-torus patch may legitimately end at its single
// collapsed inner-circle point. That point has no unique major angle,
// but (u=0,v=pi) evaluates exactly to it and permits deterministic
// trimmed-face tessellation; it does not relax projection for ordinary
// torus points away from the horn singularity.
if (planarLength <= 1e-9d)
{
if (double.Abs(torus.MajorRadius - torus.MinorRadius) <= 1e-9d && double.Abs(axial) <= 1e-9d)
{
return (0d, double.Pi);
}
return null;
}
var u = NormalizeToZeroTwoPi(double.Atan2(planar.Dot(yAxis), planar.Dot(xAxis)));
var radialFromMajor = planarLength - torus.MajorRadius;
var v = NormalizeToZeroTwoPi(double.Atan2(axial, radialFromMajor));
var residual = torus.Evaluate(u, v) - point;
var residualDistance = System.Math.Sqrt(residual.Dot(residual));
// Boundary curves of fillet/blend faces are frequently B-spline approximations of the true intersection and
// sit up to ~1e-3 mm off the analytic torus; this is a display projection, so accept deviations well below
// visual resolution instead of dropping the face.
var tolerance = System.Math.Max(AnalyticProjectionDeviationFloor, System.Math.Max(System.Math.Max(torus.MajorRadius, torus.MinorRadius) * 1e-4d, torus.MinorRadius * 1e-2d));
if (!double.IsFinite(residualDistance) || residualDistance > tolerance)
{
return null;
}
return (u, v);
}
// Boundary edges of fillet/blend faces are often B-spline approximations of the true intersection and sit a few
// 1e-3 mm off the analytic surface. UV projection here is for display, so accept anything below visual resolution.
private const double AnalyticProjectionDeviationFloor = 1e-2d;
private static (double U, double V)? TryProjectPointToCylinderUv(CylinderSurface cylinder, Point3D point, double recoveryAllowance = 0d)
{
var axis = cylinder.Axis.ToVector();
var xAxis = cylinder.XAxis.ToVector();
var yAxis = cylinder.YAxis.ToVector();
var offset = point - cylinder.Origin;
var axial = offset.Dot(axis);
var radial = offset - (axis * axial);
var radialLength = radial.Length;
// A measured recovered edge can depart from its exact cylindrical support by more than
// the analytic floor. Bound this face-local display projection by its recorded recovery
// deviation and the display chord budget; pcurve and kernel budgets remain independent.
var tolerance = System.Math.Max(recoveryAllowance, System.Math.Max(AnalyticProjectionDeviationFloor, cylinder.Radius * 1e-4d));
if (!double.IsFinite(radialLength) || System.Math.Abs(radialLength - cylinder.Radius) > tolerance)
{
return null;
}
var angle = NormalizeToZeroTwoPi(double.Atan2(radial.Dot(yAxis), radial.Dot(xAxis)));
return (angle, axial);
}
private static (double U, double V)? TryProjectPointToConeUv(ConeSurface cone, Point3D point)
{
var axis = cone.Axis.ToVector();
var xAxis = cone.ReferenceAxis.ToVector();
var projectedX = xAxis - (axis * xAxis.Dot(axis));
if (!Direction3D.TryCreate(projectedX, out var coneXAxis))
{
return null;
}
if (!Direction3D.TryCreate(axis.Cross(coneXAxis.ToVector()), out var coneYAxis))
{
return null;
}
var offset = point - cone.Apex;
var axial = offset.Dot(axis);
if (!double.IsFinite(axial) || axial < -1e-6d)
{
return null;
}
var radial = offset - (axis * axial);
var radialLength = radial.Length;
var expectedRadius = axial * double.Tan(cone.SemiAngleRadians);
var tolerance = System.Math.Max(AnalyticProjectionDeviationFloor, expectedRadius * 1e-4d);
if (System.Math.Abs(radialLength - expectedRadius) > tolerance)
{
return null;
}
var angle = radialLength <= 1e-9d
? 0d
: NormalizeToZeroTwoPi(double.Atan2(radial.Dot(coneYAxis.ToVector()), radial.Dot(coneXAxis.ToVector())));
return (angle, axial);
}
private static KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>> TryBuildTrimmedSurfaceUvLoops(
BrepBody body,
FaceId faceId,
IReadOnlyList<LoopId> loopIds,
Func<Point3D, (double U, double V)?> projectPointToUv,
DisplayTessellationOptions options,
DisplayTessellationExecutionBudget? executionBudget = null,
SurfaceGeometryKind? surfaceKind = null,
bool preferBoundPcurves = true)
{
var uvLoops = new List<IReadOnlyList<(double U, double V)>>(loopIds.Count);
foreach (var loopId in loopIds.OrderBy(id => id.Value))
{
executionBudget?.ThrowIfExpired("TrimLoopDispatch", faceId, surfaceKind);
var uvLoop = TryBuildTrimmedSurfaceUvLoop(body, faceId, loopId, projectPointToUv, options, executionBudget, surfaceKind, preferBoundPcurves);
if (!uvLoop.IsSuccess)
{
return KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Failure(uvLoop.Diagnostics);
}
uvLoops.Add(uvLoop.Value);
}
return KernelResult<IReadOnlyList<IReadOnlyList<(double U, double V)>>>.Success(uvLoops);
}
private static KernelResult<IReadOnlyList<(double U, double V)>> TryBuildTrimmedSurfaceUvLoop(
BrepBody body,
FaceId faceId,
LoopId loopId,
Func<Point3D, (double U, double V)?> projectPointToUv,
DisplayTessellationOptions options,
DisplayTessellationExecutionBudget? executionBudget = null,
SurfaceGeometryKind? surfaceKind = null,
bool preferBoundPcurves = true)
{
var coedges = body.GetCoedgeIds(loopId).Select(id => body.Topology.GetCoedge(id)).ToArray();
if (coedges.Length == 0)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
CreateNotImplemented(
$"Face {faceId.Value} parametric trim loop has no coedges.",
BSplineSurfaceTrimUnsupportedSource)]);
}
var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
if (!vertexPointsResult.IsSuccess)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(vertexPointsResult.Diagnostics);
}
var uvPoints = new List<(double U, double V)>();
foreach (var coedge in coedges)
{
executionBudget?.ThrowIfExpired("TrimLoopSampling", faceId, surfaceKind);
// Consume the bound face-space authority when available. Numerical 3D
// reprojection is only the legacy fallback for bodies without pcurves.
if (preferBoundPcurves && body.Bindings.TryGetPcurveBinding(coedge.Id, out var pc) && pc.FaceId == faceId)
{
var edge = body.Bindings.GetEdgeBinding(coedge.EdgeId);
var reversed = coedge.IsReversed ^ !edge.OrientedEdgeSense ^ !pc.SameSense;
var segments = pc.Pcurve.Kind == PcurveGeometryKind.Line ? 2 : System.Math.Max(32, options.MinimumSegments);
// Imported analytic pcurves may use different equivalent angular
// charts on neighbouring edges. Translate the whole coedge by an
// integral turn at its join; preserve its authored sweep internally.
// Pointwise wrapping would erase legitimate multi-turn helices.
var angularOffset = 0d;
if (uvPoints.Count > 0 && surfaceKind is SurfaceGeometryKind.Cylinder or SurfaceGeometryKind.Cone)
{
var first = pc.Pcurve.Evaluate(reversed ? pc.Pcurve.Domain.End : pc.Pcurve.Domain.Start);
angularOffset = 2d * double.Pi * double.Round((uvPoints[^1].U - first.U) / (2d * double.Pi));
}
for (var i = 0; i <= segments; i++)
{
var fraction = (double)i / segments;
if (reversed) fraction = 1 - fraction;
var uv = pc.Pcurve.Evaluate(pc.Pcurve.Domain.Start + fraction * (pc.Pcurve.Domain.End - pc.Pcurve.Domain.Start));
AppendUniqueUvPoint(uvPoints, (uv.U + angularOffset, uv.V));
}
continue;
}
var sampledCurve = TrySampleCoedgeForTrimEvaluation(body, faceId, coedge, vertexPointsResult.Value, options, executionBudget, surfaceKind);
if (!sampledCurve.IsSuccess)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure(sampledCurve.Diagnostics);
}
foreach (var point in sampledCurve.Value)
{
var uv = projectPointToUv(point);
if (!uv.HasValue)
{
return KernelResult<IReadOnlyList<(double U, double V)>>.Failure([
CreateNotImplemented(
$"Face {faceId.Value} parametric trim tessellation could not project loop samples into the parametric domain.",
BSplineSurfaceTrimUnsupportedSource)]);
}
AppendUniqueUvPoint(uvPoints, uv.Value);
}
}
if (uvPoints.Count > 1 && UvPointsAlmostEqual(uvPoints[0], uvPoints[^1]))
{
uvPoints.RemoveAt(uvPoints.Count - 1);
}
return KernelResult<IReadOnlyList<(double U, double V)>>.Success(uvPoints);
}
private static KernelResult<IReadOnlyList<Point3D>> TrySampleCoedgeForTrimEvaluation(
BrepBody body,
FaceId faceId,
Coedge coedge,
IReadOnlyDictionary<VertexId, Point3D> vertexPoints,
DisplayTessellationOptions options,
DisplayTessellationExecutionBudget? executionBudget = null,
SurfaceGeometryKind? surfaceKind = null)
{
executionBudget?.ThrowIfExpired("TrimCoedgeSampling", faceId, surfaceKind);
var endpoints = GetEdgeEndpoints(body, coedge.EdgeId, coedge.IsReversed, vertexPoints);
if (!endpoints.IsSuccess)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure(endpoints.Diagnostics);
}
var polylineResult = TessellateEdge(body, coedge.EdgeId, options);
if (!polylineResult.IsSuccess)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure(polylineResult.Diagnostics);
}
var sampled = polylineResult.Value.Points.ToArray();
if (sampled.Length < 2)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure([
CreateNotImplemented($"Face {faceId.Value} trim edge {coedge.EdgeId.Value} did not produce enough samples.", BSplineSurfaceTrimUnsupportedSource)]);
}
var directDistance = DistanceSquared(sampled[0], endpoints.Value.Start) + DistanceSquared(sampled[^1], endpoints.Value.End);
var reversedDistance = DistanceSquared(sampled[0], endpoints.Value.End) + DistanceSquared(sampled[^1], endpoints.Value.Start);
if (reversedDistance < directDistance)
{
Array.Reverse(sampled);
}
sampled[0] = endpoints.Value.Start;
sampled[^1] = endpoints.Value.End;
return KernelResult<IReadOnlyList<Point3D>>.Success(sampled);
}
private static void AppendUniqueUvPoint(List<(double U, double V)> points, (double U, double V) point)
{
if (points.Count == 0 || !UvPointsAlmostEqual(points[^1], point))
{
points.Add(point);
}
}
private static bool UvPointsAlmostEqual((double U, double V) left, (double U, double V) right)
=> System.Math.Abs(left.U - right.U) <= LoopEndpointTolerance
&& System.Math.Abs(left.V - right.V) <= LoopEndpointTolerance;
private static double DistanceSquared(Point3D left, Point3D right)
{
var delta = left - right;
return delta.Dot(delta);
}
private static double ComputeBSplineProjectionTolerance(BSplineSurfaceWithKnots surface)
{
var points = surface.ControlPoints.SelectMany(row => row).ToArray();
if (points.Length == 0)
{
return 1e-4d;
}
var minX = points.Min(point => point.X);
var minY = points.Min(point => point.Y);
var minZ = points.Min(point => point.Z);
var maxX = points.Max(point => point.X);
var maxY = points.Max(point => point.Y);
var maxZ = points.Max(point => point.Z);
var diagonal = new Vector3D(maxX - minX, maxY - minY, maxZ - minZ).Length;
// Vendor STEP files carry edge curves that only agree with their face surfaces to the exporting CAD
// system's accuracy; measured on a McMaster bevel pinion the worst edge-to-surface gap is about 7 microns.
// Loop samples that close to a surface are still unambiguously on it, so the tolerance has a 50 micron
// floor (model units are mm after import normalization). NIST rational patches sit up to ~20 microns off
// their boundary edges even with exact NURBS evaluation.
return System.Math.Max(5e-2d, diagonal * 1e-4d);
}
private static Vector3D EvaluateBSplineNormal(BSplineSurfaceWithKnots surface, double u, double v)
{
var du = System.Math.Max((surface.DomainEndU - surface.DomainStartU) * 1e-4d, 1e-6d);
var dv = System.Math.Max((surface.DomainEndV - surface.DomainStartV) * 1e-4d, 1e-6d);
var uMinus = System.Math.Clamp(u - du, surface.DomainStartU, surface.DomainEndU);
var uPlus = System.Math.Clamp(u + du, surface.DomainStartU, surface.DomainEndU);
var vMinus = System.Math.Clamp(v - dv, surface.DomainStartV, surface.DomainEndV);
var vPlus = System.Math.Clamp(v + dv, surface.DomainStartV, surface.DomainEndV);
var tangentU = surface.Evaluate(uPlus, v) - surface.Evaluate(uMinus, v);
var tangentV = surface.Evaluate(u, vPlus) - surface.Evaluate(u, vMinus);
// Finite-difference lengths depend on parameter scale. Rescale before
// the cross product so a regular, small ruled face is not mistaken for
// a singularity (notably near an involute's zero-speed base endpoint).
static Vector3D Rescale(Vector3D t)
{
var scale = System.Math.Max(System.Math.Abs(t.X), System.Math.Max(System.Math.Abs(t.Y), System.Math.Abs(t.Z)));
// Component division is intentional: Vector3D's geometric division
// guard treats small physical lengths as zero; this scale is relative.
return scale > 0 && double.IsFinite(scale) ? new(t.X / scale, t.Y / scale, t.Z / scale) : t;
}
tangentU = Rescale(tangentU);
tangentV = Rescale(tangentV);
var normal = tangentU.Cross(tangentV);
if (!normal.TryNormalize(out var normalized))
{
return new Vector3D(0d, 0d, 1d);
}
return normalized;
}
private static KernelResult<DisplayFaceMeshPatch> TessellateEllipsoidFace(BrepBody body, FaceId faceId,
EllipsoidSurface ellipsoid, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? budget)
{
// Affine pullback to the existing spherical trim authority. Refinement's
// unit-sphere chord bound is tightened by the largest singular value.
var loops = new List<IReadOnlyList<Point3D>>();
foreach (var loop in body.GetLoopIds(faceId))
{
var coedges = body.GetCoedgeIds(loop).Select(body.Topology.GetCoedge).ToArray();
var lookup = BuildLoopVertexPointLookup(body, coedges, faceId);
if (!lookup.IsSuccess) return KernelResult<DisplayFaceMeshPatch>.Failure(lookup.Diagnostics);
var points = new List<Point3D>();
foreach (var use in coedges)
{
var samples = TrySampleCoedgeForTrimEvaluation(body, faceId, use, lookup.Value, options, budget, SurfaceGeometryKind.Ellipsoid);
if (!samples.IsSuccess) return KernelResult<DisplayFaceMeshPatch>.Failure(samples.Diagnostics);
points.AddRange(samples.Value.Skip(points.Count > 0 ? 1 : 0).Select(p => Point3D.Origin + ellipsoid.UnitCoordinates(p)));
}
loops.Add(points);
}
var unit = new SphereSurface(Point3D.Origin, Direction3D.Create(new Vector3D(0, 0, 1)), 1, Direction3D.Create(new Vector3D(1, 0, 0)));
var mesh = SphericalTrimTessellator.Tessellate(faceId, unit, loops, 0,
body.Bindings.GetFaceBinding(faceId).Orientation.IsAlignedWithSurface,
options with { ChordTolerance = options.ChordTolerance / double.Max(ellipsoid.RadiusX, double.Max(ellipsoid.RadiusY, ellipsoid.RadiusZ)) }, budget);
if (!mesh.IsSuccess) return mesh;
var positions = mesh.Value.Positions.Select(ellipsoid.FromUnit).ToArray();
return KernelResult<DisplayFaceMeshPatch>.Success(mesh.Value with
{ Positions = positions, Normals = positions.Select(ellipsoid.Normal).ToArray() }, mesh.Diagnostics);
}
private static KernelResult<DisplayFaceMeshPatch> TessellateSphereFace(BrepBody body, FaceId faceId, SphereSurface sphere, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
{
var edgeLoops = body.GetLoopIds(faceId).Where(id => body.Topology.GetLoop(id).Kind == LoopKind.Edge).ToArray();
if (edgeLoops.Length > 0)
{
var sampledLoops = new List<(LoopId Id, IReadOnlyList<Point3D> Points)>();
foreach (var loopId in edgeLoops)
{
var coedges = body.GetCoedgeIds(loopId).Select(body.Topology.GetCoedge).ToArray();
var vertices = BuildLoopVertexPointLookup(body, coedges, faceId);
if (!vertices.IsSuccess) return KernelResult<DisplayFaceMeshPatch>.Failure(vertices.Diagnostics);
var points = new List<Point3D>();
foreach (var coedge in coedges)
{
var sampled = TrySampleCoedgeForTrimEvaluation(body, faceId, coedge, vertices.Value, options, executionBudget, SurfaceGeometryKind.Sphere);
if (!sampled.IsSuccess) return KernelResult<DisplayFaceMeshPatch>.Failure(sampled.Diagnostics);
var boundarySamples = sampled.Value;
var edge = body.Topology.GetEdge(coedge.EdgeId);
if (body.Bindings.TryGetPcurveBinding(coedge.Id, out var pc) && pc.FaceId == faceId)
{
var binding = body.Bindings.GetEdgeBinding(edge.Id);
var reversed = coedge.IsReversed ^ !binding.OrientedEdgeSense ^ !pc.SameSense;
var count = System.Math.Max(32, boundarySamples.Count - 1);
boundarySamples = Enumerable.Range(0, count + 1).Select(i =>
{
var t = reversed ? 1d - (double)i / count : (double)i / count;
var uv = pc.Pcurve.Evaluate(pc.Pcurve.Domain.Start + t * (pc.Pcurve.Domain.End - pc.Pcurve.Domain.Start));
return sphere.Evaluate(uv.U, uv.V);
}).ToArray();
}
// Endpoint matching cannot determine a closed edge's direction.
// The spherical chart needs directed winding to choose the cap;
// consume the existing coedge/curve sense for that singular case.
else if (edge.StartVertexId == edge.EndVertexId && (coedge.IsReversed ^ !body.Bindings.GetEdgeBinding(edge.Id).OrientedEdgeSense))
boundarySamples = boundarySamples.Reverse().ToArray();
points.AddRange(boundarySamples.Skip(points.Count > 0 ? 1 : 0));
}
sampledLoops.Add((loopId, points));
}
var outerIndex = Array.FindIndex(edgeLoops, id => body.Bindings.TryGetFaceBoundaryRoleBinding(id, out var role) && role.Role == FaceBoundaryRole.Outer);
return SphericalTrimTessellator.Tessellate(faceId, sphere, sampledLoops.Select(l => l.Points).ToArray(),
outerIndex < 0 ? 0 : outerIndex, body.Bindings.GetFaceBinding(faceId).Orientation.IsAlignedWithSurface,
options, executionBudget);
}
// With no edge boundary, retained vertex loops are zero-dimensional punctures of the support.
var angularSegments = CalculateSegmentCount(2d * double.Pi, sphere.Radius, options);
var elevationSegments = System.Math.Max(2, System.Math.Clamp(angularSegments / 2, options.MinimumSegments / 2, options.MaximumSegments));
return KernelResult<DisplayFaceMeshPatch>.Success(CreateBoundedGridPatch(
faceId,
angularSegments,
elevationSegments,
(u, v) => sphere.Evaluate(u, v),
(u, v) => sphere.Normal(u, v).ToVector(),
0d,
2d * double.Pi,
-double.Pi / 2d,
double.Pi / 2d));
}
private static KernelResult<DisplayFaceMeshPatch> TessellateTorusFace(BrepBody body, FaceId faceId, TorusSurface torus, DisplayTessellationOptions options, DisplayTessellationExecutionBudget? executionBudget = null)
{
var loopIds = body.GetLoopIds(faceId)
.Where(loopId => body.Topology.GetLoop(loopId).Kind == LoopKind.Edge)
.ToArray();
if (loopIds.Length == 2 && TryResolveCoaxialCirclePairTorusBand(body, torus, loopIds, out var bandVStart, out var bandVEnd))
{
// Two full parallel circles bound a band of the tube: the generic trim path sees two degenerate
// (zero-area) loops in UV, so tessellate the band directly as a periodic grid.
return KernelResult<DisplayFaceMeshPatch>.Success(CreatePeriodicGridPatch(
faceId,
CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, torus.MajorRadius + torus.MinorRadius), options),
CalculateSegmentCount(bandVEnd - bandVStart, System.Math.Max(1e-6d, torus.MinorRadius), options),
(u, v) => torus.Evaluate(u, v),
(u, v) => torus.Normal(u, v).ToVector(),
bandVStart,
bandVEnd));
}
if (loopIds.Length > 0)
{
var uvLoopsResult = TryBuildDoublyPeriodicTrimmedSurfaceUvLoops(body, faceId, loopIds, point => TryProjectPointToTorusUv(torus, point), options, executionBudget, SurfaceGeometryKind.Torus);
if (!uvLoopsResult.IsSuccess)
{
return KernelResult<DisplayFaceMeshPatch>.Success(
CreateEmptyPlanarPatch(faceId),
[CreateValidationWarning(
$"Face {faceId.Value} torus trim evaluation failed; skipping face patch to avoid misleading untrimmed geometry. Cause: {uvLoopsResult.Diagnostics.FirstOrDefault()?.Message}",
TrimEvaluationFailedSource)]);
}
return TrimmedSurfaceTessellator.Tessellate(
faceId,
uvLoopsResult.Value,
(u, v) => torus.Evaluate(u, v),
(u, v) => torus.Normal(u, v).ToVector(),
options,
double.NegativeInfinity,
double.PositiveInfinity,
double.NegativeInfinity,
double.PositiveInfinity,
CreateValidationWarning,
executionBudget,
SurfaceGeometryKind.Torus);
}
var parameters = GetRevolvedFaceParameters(body, faceId, options, radiusHint: torus.MajorRadius + torus.MinorRadius, allowThreeCoedgeConeTopology: false, axialParameterFromPoint: point => TorusMinorAngleOf(torus, point));
if (!parameters.IsSuccess)
{
return KernelResult<DisplayFaceMeshPatch>.Failure(parameters.Diagnostics);
}
return KernelResult<DisplayFaceMeshPatch>.Success(CreatePeriodicGridPatch(
faceId,
parameters.Value.AngularSegments,
CalculateSegmentCount(parameters.Value.VEnd - parameters.Value.VStart, System.Math.Max(1e-6d, torus.MinorRadius), options),
(u, v) => torus.Evaluate(u, v),
(u, v) => torus.Normal(u, v).ToVector(),
parameters.Value.VStart,
parameters.Value.VEnd));
}
private static KernelResult<(double VStart, double VEnd, int AngularSegments, int AxialSegments)> GetRevolvedFaceParameters(
BrepBody body,
FaceId faceId,
DisplayTessellationOptions options,
double radiusHint,
bool allowThreeCoedgeConeTopology,
Func<Point3D, double>? axialParameterFromPoint = null)
{
var coedgesResult = TryGetSupportedRevolvedCoedges(body, faceId);
if (!coedgesResult.IsSuccess)
{
return KernelResult<(double, double, int, int)>.Failure(coedgesResult.Diagnostics);
}
var coedges = coedgesResult.Value;
var lineCoedges = coedges.Where(c => body.GetEdgeCurve(c.EdgeId).Kind == CurveGeometryKind.Line3).ToArray();
var circleCoedges = coedges.Where(c => body.GetEdgeCurve(c.EdgeId).Kind == CurveGeometryKind.Circle3).ToArray();
var bSplineCoedges = coedges.Where(c => body.GetEdgeCurve(c.EdgeId).Kind == CurveGeometryKind.BSpline3).ToArray();
if (TryResolveFourUseMixedRevolvedLoop(body, coedges, lineCoedges, circleCoedges, axialParameterFromPoint, faceId, out var mixedRevolvedParameters, out var mixedRevolvedDiagnostics))
{
return KernelResult<(double, double, int, int)>.Success((
mixedRevolvedParameters.VStart,
mixedRevolvedParameters.VEnd,
CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
CalculateAxialSegments(mixedRevolvedParameters.VStart, mixedRevolvedParameters.VEnd, options)), mixedRevolvedDiagnostics);
}
if (TryResolveFourUseCircleBsplineRevolvedLoop(body, coedges, circleCoedges, bSplineCoedges, axialParameterFromPoint, faceId, out var circleBsplineParameters, out var circleBsplineDiagnostics))
{
return KernelResult<(double, double, int, int)>.Success((
circleBsplineParameters.VStart,
circleBsplineParameters.VEnd,
CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
CalculateAxialSegments(circleBsplineParameters.VStart, circleBsplineParameters.VEnd, options)), circleBsplineDiagnostics);
}
if (TryResolveFourCoedgeSingleCircleThreeBsplineRevolvedLoop(body, coedges, circleCoedges, bSplineCoedges, axialParameterFromPoint, faceId, out var fourCoedgeSingleCircleParameters, out var fourCoedgeSingleCircleDiagnostics))
{
return KernelResult<(double, double, int, int)>.Success((
fourCoedgeSingleCircleParameters.VStart,
fourCoedgeSingleCircleParameters.VEnd,
CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
CalculateAxialSegments(fourCoedgeSingleCircleParameters.VStart, fourCoedgeSingleCircleParameters.VEnd, options)), fourCoedgeSingleCircleDiagnostics);
}
if (TryResolveFourCoedgeThreeCircleSingleBsplineRevolvedLoop(body, coedges, circleCoedges, bSplineCoedges, axialParameterFromPoint, faceId, out var fourCoedgeThreeCircleParameters, out var fourCoedgeThreeCircleDiagnostics))
{
return KernelResult<(double, double, int, int)>.Success((
fourCoedgeThreeCircleParameters.VStart,
fourCoedgeThreeCircleParameters.VEnd,
CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
CalculateAxialSegments(fourCoedgeThreeCircleParameters.VStart, fourCoedgeThreeCircleParameters.VEnd, options)), fourCoedgeThreeCircleDiagnostics);
}
if (TryResolveFourUseBsplineOnlyRevolvedLoop(body, coedges, bSplineCoedges, axialParameterFromPoint, faceId, out var bsplineOnlyParameters, out var bsplineOnlyDiagnostics))
{
return KernelResult<(double, double, int, int)>.Success((
bsplineOnlyParameters.VStart,
bsplineOnlyParameters.VEnd,
CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
CalculateAxialSegments(bsplineOnlyParameters.VStart, bsplineOnlyParameters.VEnd, options)), bsplineOnlyDiagnostics);
}
if (TryResolveRepeatedCircleBsplineRevolvedLoop(body, coedges, circleCoedges, bSplineCoedges, axialParameterFromPoint, faceId, out var repeatedCircleBsplineParameters, out var repeatedCircleBsplineDiagnostics))
{
return KernelResult<(double, double, int, int)>.Success((
repeatedCircleBsplineParameters.VStart,
repeatedCircleBsplineParameters.VEnd,
CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
CalculateAxialSegments(repeatedCircleBsplineParameters.VStart, repeatedCircleBsplineParameters.VEnd, options)), repeatedCircleBsplineDiagnostics);
}
if (TryResolveSixCoedgeSingleCircleFiveBsplineRevolvedLoop(body, coedges, circleCoedges, bSplineCoedges, axialParameterFromPoint, faceId, out var sixCoedgeSingleCircleParameters, out var sixCoedgeSingleCircleDiagnostics))
{
return KernelResult<(double, double, int, int)>.Success((
sixCoedgeSingleCircleParameters.VStart,
sixCoedgeSingleCircleParameters.VEnd,
CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
CalculateAxialSegments(sixCoedgeSingleCircleParameters.VStart, sixCoedgeSingleCircleParameters.VEnd, options)), sixCoedgeSingleCircleDiagnostics);
}
if (TryResolveSixUseBsplineOnlyRevolvedLoop(body, coedges, bSplineCoedges, axialParameterFromPoint, faceId, out var sixUseBsplineOnlyParameters, out var sixUseBsplineOnlyDiagnostics))
{
return KernelResult<(double, double, int, int)>.Success((
sixUseBsplineOnlyParameters.VStart,
sixUseBsplineOnlyParameters.VEnd,
CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
CalculateAxialSegments(sixUseBsplineOnlyParameters.VStart, sixUseBsplineOnlyParameters.VEnd, options)), sixUseBsplineOnlyDiagnostics);
}
if (TryResolveDualSeamCircleRevolvedLoop(body, coedges, lineCoedges, circleCoedges, axialParameterFromPoint, faceId, out var dualSeamCircleParameters, out var dualSeamCircleDiagnostics))
{
return KernelResult<(double, double, int, int)>.Success((
dualSeamCircleParameters.VStart,
dualSeamCircleParameters.VEnd,
CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
CalculateAxialSegments(dualSeamCircleParameters.VStart, dualSeamCircleParameters.VEnd, options)), dualSeamCircleDiagnostics);
}
if (TryResolveRepeatedMixedRevolvedLoop(body, coedges, lineCoedges, circleCoedges, axialParameterFromPoint, faceId, out var repeatedMixedParameters, out var repeatedMixedDiagnostics))
{
return KernelResult<(double, double, int, int)>.Success((
repeatedMixedParameters.VStart,
repeatedMixedParameters.VEnd,
CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options),
CalculateAxialSegments(repeatedMixedParameters.VStart, repeatedMixedParameters.VEnd, options)), repeatedMixedDiagnostics);
}
if (allowThreeCoedgeConeTopology && TryResolveThreeCoedgeBsplineConeLoop(body, coedges, bSplineCoedges, axialParameterFromPoint, faceId, out var threeCoedgeBsplineParameters, out var threeCoedgeBsplineDiagnostics))
{
var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
var axialSegments = CalculateAxialSegments(threeCoedgeBsplineParameters.VStart, threeCoedgeBsplineParameters.VEnd, options);
return KernelResult<(double, double, int, int)>.Success((threeCoedgeBsplineParameters.VStart, threeCoedgeBsplineParameters.VEnd, angularSegments, axialSegments), threeCoedgeBsplineDiagnostics);
}
if (allowThreeCoedgeConeTopology && TryResolveThreeCoedgeMixedCircleBsplineConeLoop(body, coedges, circleCoedges, bSplineCoedges, axialParameterFromPoint, faceId, out var threeCoedgeMixedCircleBsplineParameters, out var threeCoedgeMixedCircleBsplineDiagnostics))
{
var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
var axialSegments = CalculateAxialSegments(threeCoedgeMixedCircleBsplineParameters.VStart, threeCoedgeMixedCircleBsplineParameters.VEnd, options);
return KernelResult<(double, double, int, int)>.Success((threeCoedgeMixedCircleBsplineParameters.VStart, threeCoedgeMixedCircleBsplineParameters.VEnd, angularSegments, axialSegments), threeCoedgeMixedCircleBsplineDiagnostics);
}
if (allowThreeCoedgeConeTopology && TryResolveConeRevolvedLoop(body, coedges, lineCoedges, circleCoedges, axialParameterFromPoint, faceId, out var coneRevolvedParameters, out var coneRevolvedDiagnostics))
{
var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
var axialSegments = CalculateAxialSegments(coneRevolvedParameters.VStart, coneRevolvedParameters.VEnd, options);
return KernelResult<(double, double, int, int)>.Success((coneRevolvedParameters.VStart, coneRevolvedParameters.VEnd, angularSegments, axialSegments), coneRevolvedDiagnostics);
}
if (allowThreeCoedgeConeTopology && TryResolveSingleCoedgeCircleSeamReusedConeLoop(body, coedges, lineCoedges, circleCoedges, axialParameterFromPoint, faceId, out var singleCoedgeCircleSeamReusedConeParameters, out var singleCoedgeCircleSeamReusedConeDiagnostics))
{
var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
var axialSegments = CalculateAxialSegments(singleCoedgeCircleSeamReusedConeParameters.VStart, singleCoedgeCircleSeamReusedConeParameters.VEnd, options);
return KernelResult<(double, double, int, int)>.Success((singleCoedgeCircleSeamReusedConeParameters.VStart, singleCoedgeCircleSeamReusedConeParameters.VEnd, angularSegments, axialSegments), singleCoedgeCircleSeamReusedConeDiagnostics);
}
if (TryResolveFourUseCircleOnlyNonSeamRevolvedLoop(body, coedges, lineCoedges, circleCoedges, axialParameterFromPoint, faceId, out var fourUseCircleOnlyNonSeamParameters, out var fourUseCircleOnlyNonSeamDiagnostics))
{
var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
var axialSegments = CalculateAxialSegments(fourUseCircleOnlyNonSeamParameters.VStart, fourUseCircleOnlyNonSeamParameters.VEnd, options);
return KernelResult<(double, double, int, int)>.Success((fourUseCircleOnlyNonSeamParameters.VStart, fourUseCircleOnlyNonSeamParameters.VEnd, angularSegments, axialSegments), fourUseCircleOnlyNonSeamDiagnostics);
}
var uniqueEdgeIds = coedges
.Select(c => c.EdgeId)
.Distinct()
.ToArray();
var allEdgeCurvesAreCircles = uniqueEdgeIds
.Select(id => body.GetEdgeCurve(id).Kind)
.All(kind => kind == CurveGeometryKind.Circle3);
if (lineCoedges.Length == 0 && circleCoedges.Length >= 4 && uniqueEdgeIds.Length == 2 && allEdgeCurvesAreCircles)
{
var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
var axialSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
return KernelResult<(double, double, int, int)>.Success((0d, 2d * double.Pi, angularSegments, axialSegments));
}
if (axialParameterFromPoint is not null)
{
var projectedVertexBounds = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
if (projectedVertexBounds.IsSuccess)
{
var angularSegments = CalculateSegmentCount(2d * double.Pi, System.Math.Max(1e-6d, radiusHint), options);
var axialSegments = CalculateAxialSegments(projectedVertexBounds.Value.VStart, projectedVertexBounds.Value.VEnd, options);
return KernelResult<(double, double, int, int)>.Success((projectedVertexBounds.Value.VStart, projectedVertexBounds.Value.VEnd, angularSegments, axialSegments));
}
}
var topologyFamily = allowThreeCoedgeConeTopology ? "cone/revolved" : "torus/revolved";
var observedFamily = ClassifyRevolvedTopologyFamily(body, coedges, lineCoedges, circleCoedges, bSplineCoedges);
return KernelResult<(double, double, int, int)>.Failure([CreateNotImplemented($"Face {faceId.Value} curved tessellation supports selected repeated {topologyFamily} boundary subfamilies; unsupported subfamily '{observedFamily}'. Observed: {DescribeRevolvedLoopTopology(body, coedges)}")]);
}
private static KernelResult<IReadOnlyList<Coedge>> TryGetSupportedRevolvedCoedges(BrepBody body, FaceId faceId)
{
var loopIds = body.GetLoopIds(faceId)
.Where(loopId => body.Topology.GetLoop(loopId).Kind == LoopKind.Edge)
.ToArray();
if (loopIds.Length == 1)
{
var singleLoopCoedges = body.GetCoedgeIds(loopIds[0])
.Select(id => body.Topology.GetCoedge(id))
.ToArray();
return KernelResult<IReadOnlyList<Coedge>>.Success(singleLoopCoedges);
}
if (TryResolvePreservedPeriodicDualSeamCircleLoopFamily(body, loopIds, out var preservedFamilyCoedges))
{
return KernelResult<IReadOnlyList<Coedge>>.Success(preservedFamilyCoedges);
}
return KernelResult<IReadOnlyList<Coedge>>.Failure([
CreateNotImplemented($"Face {faceId.Value} curved tessellation supports exactly one loop or the preserved periodic dual single-coedge seam-circle loop family. Observed: {DescribeRevolvedFaceTopology(body, loopIds)}", CurvedTopologyUnsupportedSource)
]);
}
private static bool TryResolvePreservedPeriodicDualSeamCircleLoopFamily(
BrepBody body,
IReadOnlyList<LoopId> loopIds,
out IReadOnlyList<Coedge> coedges)
{
coedges = [];
if (loopIds.Count != 2)
{
return false;
}
var resolved = new List<Coedge>(2);
foreach (var loopId in loopIds)
{
var coedgeIds = body.GetCoedgeIds(loopId);
if (coedgeIds.Count != 1)
{
return false;
}
var coedge = body.Topology.GetCoedge(coedgeIds[0]);
if (body.GetEdgeCurve(coedge.EdgeId).Kind != CurveGeometryKind.Circle3)
{
return false;
}
var edge = body.Topology.GetEdge(coedge.EdgeId);
if (edge.StartVertexId != edge.EndVertexId)
{
return false;
}
resolved.Add(coedge);
}
coedges = resolved;
return true;
}
private static bool TryResolveRepeatedCircleBsplineRevolvedLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> circleCoedges,
IReadOnlyList<Coedge> bSplineCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (coedges.Count < 5 || circleCoedges.Count < 2 || bSplineCoedges.Count < 1 || axialParameterFromPoint is null)
{
return false;
}
var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveFourUseCircleOnlyNonSeamRevolvedLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> lineCoedges,
IReadOnlyList<Coedge> circleCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (axialParameterFromPoint is null || coedges.Count != 4 || lineCoedges.Count != 0 || circleCoedges.Count != 4)
{
return false;
}
var uniqueEdgeIds = coedges.Select(c => c.EdgeId).Distinct().ToArray();
if (uniqueEdgeIds.Length != 4)
{
return false;
}
var seamUses = coedges.Count(c =>
{
var edge = body.Topology.GetEdge(c.EdgeId);
return edge.StartVertexId == edge.EndVertexId;
});
if (seamUses != 0)
{
return false;
}
var allEdgeCurvesAreCircles = uniqueEdgeIds
.Select(id => body.GetEdgeCurve(id).Kind)
.All(kind => kind == CurveGeometryKind.Circle3);
if (!allEdgeCurvesAreCircles)
{
return false;
}
var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveDualSeamCircleRevolvedLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> lineCoedges,
IReadOnlyList<Coedge> circleCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (axialParameterFromPoint is null || coedges.Count != 2 || lineCoedges.Count != 0 || circleCoedges.Count != 2)
{
return false;
}
var seamUses = coedges.Count(c =>
{
var edge = body.Topology.GetEdge(c.EdgeId);
return edge.StartVertexId == edge.EndVertexId;
});
if (seamUses != 2 || coedges.Select(c => c.EdgeId).Distinct().Count() != 2)
{
return false;
}
var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveSingleCoedgeCircleSeamReusedConeLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> lineCoedges,
IReadOnlyList<Coedge> circleCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (axialParameterFromPoint is null || coedges.Count != 1 || lineCoedges.Count != 0 || circleCoedges.Count != 1)
{
return false;
}
var coedge = coedges[0];
var edge = body.Topology.GetEdge(coedge.EdgeId);
if (edge.StartVertexId != edge.EndVertexId)
{
return false;
}
if (body.GetEdgeCurve(coedge.EdgeId).Kind != CurveGeometryKind.Circle3)
{
return false;
}
var vertexPoint = GetVertexPoint(body, edge.StartVertexId);
if (!vertexPoint.IsSuccess)
{
diagnostics = vertexPoint.Diagnostics;
return false;
}
var trimV = axialParameterFromPoint(vertexPoint.Value);
if (!double.IsFinite(trimV) || trimV <= 1e-8d)
{
diagnostics =
[
CreateNotImplemented($"Face {faceId.Value} curved tessellation could not derive finite non-degenerate axial bounds for single-coedge seam-reused circle cone topology. Observed: {DescribeRevolvedLoopTopology(body, coedges)}", CurvedTopologyUnsupportedSource)
];
return false;
}
parameters = (0d, trimV);
return true;
}
private static bool TryResolveRepeatedMixedRevolvedLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> lineCoedges,
IReadOnlyList<Coedge> circleCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (coedges.Count < 5 || lineCoedges.Count < 2 || circleCoedges.Count < 2)
{
return false;
}
var lineEdgeIds = lineCoedges.Select(c => c.EdgeId).Distinct().ToArray();
if (lineEdgeIds.Length == 0)
{
return false;
}
var result = TryResolveAxialBoundsFromLines(body, coedges, lineEdgeIds, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveSixCoedgeSingleCircleFiveBsplineRevolvedLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> circleCoedges,
IReadOnlyList<Coedge> bSplineCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
var uniqueEdgeCount = coedges.Select(c => c.EdgeId).Distinct().Count();
if (coedges.Count != 6 || uniqueEdgeCount != 6 || circleCoedges.Count != 1 || bSplineCoedges.Count != 5 || axialParameterFromPoint is null)
{
return false;
}
var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveFourUseMixedRevolvedLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> lineCoedges,
IReadOnlyList<Coedge> circleCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (coedges.Count != 4 || lineCoedges.Count != 2 || circleCoedges.Count != 2)
{
return false;
}
var result = TryResolveAxialBoundsFromLines(body, coedges, lineCoedges.Select(c => c.EdgeId).Distinct().ToArray(), axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveFourUseCircleBsplineRevolvedLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> circleCoedges,
IReadOnlyList<Coedge> bSplineCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (coedges.Count != 4 || circleCoedges.Count != 2 || bSplineCoedges.Count != 2 || axialParameterFromPoint is null)
{
return false;
}
var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveFourUseBsplineOnlyRevolvedLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> bSplineCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (coedges.Count != 4 || bSplineCoedges.Count != 4 || axialParameterFromPoint is null)
{
return false;
}
var uniqueEdgeCount = coedges
.Select(c => c.EdgeId)
.Distinct()
.Count();
if (uniqueEdgeCount != 4)
{
return false;
}
var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveSixUseBsplineOnlyRevolvedLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> bSplineCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (coedges.Count != 6 || bSplineCoedges.Count != 6 || axialParameterFromPoint is null)
{
return false;
}
var uniqueEdgeCount = coedges
.Select(c => c.EdgeId)
.Distinct()
.Count();
if (uniqueEdgeCount != 6)
{
return false;
}
var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveFourCoedgeSingleCircleThreeBsplineRevolvedLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> circleCoedges,
IReadOnlyList<Coedge> bSplineCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (coedges.Count != 4 || circleCoedges.Count != 1 || bSplineCoedges.Count != 3 || axialParameterFromPoint is null)
{
return false;
}
var uniqueEdgeCount = coedges
.Select(c => c.EdgeId)
.Distinct()
.Count();
if (uniqueEdgeCount < 3)
{
return false;
}
var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveFourCoedgeThreeCircleSingleBsplineRevolvedLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> circleCoedges,
IReadOnlyList<Coedge> bSplineCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (coedges.Count != 4 || circleCoedges.Count != 3 || bSplineCoedges.Count != 1 || axialParameterFromPoint is null)
{
return false;
}
var uniqueEdgeCount = coedges
.Select(c => c.EdgeId)
.Distinct()
.Count();
if (uniqueEdgeCount != 4)
{
return false;
}
var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveConeRevolvedLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> lineCoedges,
IReadOnlyList<Coedge> circleCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (coedges.Count < 3 || lineCoedges.Count < 2 || circleCoedges.Count < 1)
{
return false;
}
var lineEdgeIds = lineCoedges.Select(c => c.EdgeId).Distinct().ToArray();
var result = TryResolveAxialBoundsFromLines(body, coedges, lineEdgeIds, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveThreeCoedgeMixedCircleBsplineConeLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> circleCoedges,
IReadOnlyList<Coedge> bSplineCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (coedges.Count != 3 || circleCoedges.Count != 1 || bSplineCoedges.Count != 2 || axialParameterFromPoint is null)
{
return false;
}
var uniqueEdgeCount = coedges
.Select(c => c.EdgeId)
.Distinct()
.Count();
if (uniqueEdgeCount != 3)
{
return false;
}
var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static bool TryResolveThreeCoedgeBsplineConeLoop(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> bSplineCoedges,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId,
out (double VStart, double VEnd) parameters,
out IReadOnlyList<KernelDiagnostic> diagnostics)
{
parameters = default;
diagnostics = [];
if (coedges.Count != 3 || bSplineCoedges.Count != 3 || axialParameterFromPoint is null)
{
return false;
}
var uniqueEdgeCount = coedges
.Select(c => c.EdgeId)
.Distinct()
.Count();
if (uniqueEdgeCount != 3)
{
return false;
}
var result = TryResolveAxialBoundsFromProjectedLoopVertices(body, coedges, axialParameterFromPoint, faceId);
if (!result.IsSuccess)
{
diagnostics = result.Diagnostics;
return false;
}
parameters = result.Value;
diagnostics = result.Diagnostics;
return true;
}
private static KernelResult<(double VStart, double VEnd)> TryResolveAxialBoundsFromLines(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<EdgeId> lineEdgeIds,
Func<Point3D, double>? axialParameterFromPoint,
FaceId faceId)
{
if (lineEdgeIds.Count == 0)
{
return KernelResult<(double VStart, double VEnd)>.Failure([CreateNotImplemented($"Face {faceId.Value} curved tessellation expected line trim edges for revolved topology. Observed: {DescribeRevolvedLoopTopology(body, coedges)}", CurvedTopologyUnsupportedSource)]);
}
var intervals = new List<ParameterInterval>(lineEdgeIds.Count);
foreach (var lineEdgeId in lineEdgeIds)
{
if (!body.Bindings.TryGetEdgeBinding(lineEdgeId, out var lineTrimBinding))
{
return KernelResult<(double VStart, double VEnd)>.Failure([CreateNotImplemented($"Face {faceId.Value} line trim edge is missing curve trim binding.")]);
}
intervals.Add(lineTrimBinding.TrimInterval ?? new ParameterInterval(0d, 1d));
}
var vMin = intervals.Min(i => System.Math.Min(i.Start, i.End));
var vMax = intervals.Max(i => System.Math.Max(i.Start, i.End));
var increasing = intervals[0].End >= intervals[0].Start;
var vStart = increasing ? vMin : vMax;
var vEnd = increasing ? vMax : vMin;
if (axialParameterFromPoint is not null)
{
var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
if (!vertexPointsResult.IsSuccess)
{
return KernelResult<(double VStart, double VEnd)>.Failure(vertexPointsResult.Diagnostics);
}
var projected = vertexPointsResult.Value.Values
.Select(axialParameterFromPoint)
.Where(double.IsFinite)
.ToArray();
if (projected.Length != 0)
{
var projectedMin = projected.Min();
var projectedMax = projected.Max();
vStart = increasing ? projectedMin : projectedMax;
vEnd = increasing ? projectedMax : projectedMin;
}
}
return KernelResult<(double VStart, double VEnd)>.Success((vStart, vEnd));
}
private static KernelResult<(double VStart, double VEnd)> TryResolveAxialBoundsFromProjectedLoopVertices(
BrepBody body,
IReadOnlyList<Coedge> coedges,
Func<Point3D, double> axialParameterFromPoint,
FaceId faceId)
{
var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
if (!vertexPointsResult.IsSuccess)
{
return KernelResult<(double VStart, double VEnd)>.Failure(vertexPointsResult.Diagnostics);
}
var projected = vertexPointsResult.Value.Values
.Select(axialParameterFromPoint)
.Where(double.IsFinite)
.ToArray();
if (projected.Length < 2)
{
return KernelResult<(double VStart, double VEnd)>.Failure([
CreateNotImplemented($"Face {faceId.Value} curved tessellation could not derive axial bounds from projected loop vertices. Observed: {DescribeRevolvedLoopTopology(body, coedges)}", CurvedTopologyUnsupportedSource)]);
}
var vStart = projected.Min();
var vEnd = projected.Max();
if (double.Abs(vEnd - vStart) <= 1e-9d)
{
return KernelResult<(double VStart, double VEnd)>.Failure([
CreateNotImplemented($"Face {faceId.Value} curved tessellation derived a degenerate projected axial span. Observed: {DescribeRevolvedLoopTopology(body, coedges)}", CurvedTopologyUnsupportedSource)]);
}
return KernelResult<(double VStart, double VEnd)>.Success((vStart, vEnd));
}
private static int CalculateAxialSegments(double vStart, double vEnd, DisplayTessellationOptions options)
{
var axialSpan = double.Abs(vEnd - vStart);
return System.Math.Max(1, System.Math.Clamp((int)double.Ceiling(axialSpan / options.ChordTolerance), 1, options.MaximumSegments));
}
private static string DescribeRevolvedLoopTopology(BrepBody body, IReadOnlyList<Coedge> coedges, int loopCount = 1)
{
var lineUseCount = 0;
var circleUseCount = 0;
var ellipseUseCount = 0;
var bSplineUseCount = 0;
var seamUseCount = 0;
foreach (var coedge in coedges)
{
var curve = body.GetEdgeCurve(coedge.EdgeId);
if (curve.Kind == CurveGeometryKind.Line3)
{
lineUseCount++;
}
else if (curve.Kind == CurveGeometryKind.Circle3)
{
circleUseCount++;
}
else if (curve.Kind == CurveGeometryKind.Ellipse3)
{
ellipseUseCount++;
}
else if (curve.Kind == CurveGeometryKind.BSpline3)
{
bSplineUseCount++;
}
var edge = body.Topology.GetEdge(coedge.EdgeId);
if (edge.StartVertexId == edge.EndVertexId)
{
seamUseCount++;
}
}
var edgeFamilies = coedges
.Select(c => $"{c.EdgeId.Value}:{body.GetEdgeCurve(c.EdgeId).Kind}")
.ToArray();
return $"loops={loopCount} coedges={coedges.Count} lineUses={lineUseCount} circleUses={circleUseCount} ellipseUses={ellipseUseCount} bSplineUses={bSplineUseCount} seamEdgeUses={seamUseCount} edgeFamilies=[{string.Join(", ", edgeFamilies)}]";
}
private static string DescribeRevolvedFaceTopology(BrepBody body, IReadOnlyList<LoopId> loopIds)
{
var loopDescriptions = new List<string>(loopIds.Count);
var aggregateCoedges = new List<Coedge>();
foreach (var loopId in loopIds)
{
var coedges = body.GetCoedgeIds(loopId)
.Select(id => body.Topology.GetCoedge(id))
.ToArray();
aggregateCoedges.AddRange(coedges);
var uniqueEdges = coedges.Select(c => c.EdgeId).Distinct().Count();
var circleUses = coedges.Count(c => body.GetEdgeCurve(c.EdgeId).Kind == CurveGeometryKind.Circle3);
var seamUses = coedges.Count(c =>
{
var edge = body.Topology.GetEdge(c.EdgeId);
return edge.StartVertexId == edge.EndVertexId;
});
loopDescriptions.Add($"{loopId.Value}:coedges={coedges.Length}:uniqueEdges={uniqueEdges}:circleUses={circleUses}:seamUses={seamUses}");
}
return $"{DescribeRevolvedLoopTopology(body, aggregateCoedges, loopIds.Count)} loopFamilies=[{string.Join(", ", loopDescriptions)}]";
}
private static string ClassifyRevolvedTopologyFamily(
BrepBody body,
IReadOnlyList<Coedge> coedges,
IReadOnlyList<Coedge> lineCoedges,
IReadOnlyList<Coedge> circleCoedges,
IReadOnlyList<Coedge> bSplineCoedges)
{
var uniqueEdgeIds = coedges.Select(c => c.EdgeId).Distinct().ToArray();
var seamUses = coedges.Count(c =>
{
var edge = body.Topology.GetEdge(c.EdgeId);
return edge.StartVertexId == edge.EndVertexId;
});
var evidence = new LoopPatternEvidence(
coedges.Count,
uniqueEdgeIds.Length,
lineCoedges.Count,
circleCoedges.Count,
bSplineCoedges.Count,
seamUses);
return new LoopPatternClassifier().Classify(evidence).Label;
}
private static DisplayFaceMeshPatch CreatePeriodicGridPatch(
FaceId faceId,
int angularSegments,
int axialSegments,
Func<double, double, Point3D> evaluate,
Func<double, double, Vector3D> evaluateNormal,
double vStart,
double vEnd)
{
var positions = new List<Point3D>((angularSegments + 1) * (axialSegments + 1));
var normals = new List<Vector3D>((angularSegments + 1) * (axialSegments + 1));
var indices = new List<int>(angularSegments * axialSegments * 6);
for (var v = 0; v <= axialSegments; v++)
{
var tv = (double)v / axialSegments;
var vv = vStart + ((vEnd - vStart) * tv);
for (var u = 0; u <= angularSegments; u++)
{
var tu = (double)u / angularSegments;
var uu = tu * 2d * double.Pi;
positions.Add(evaluate(uu, vv));
normals.Add(evaluateNormal(uu, vv));
}
}
var rowWidth = angularSegments + 1;
for (var v = 0; v < axialSegments; v++)
{
for (var u = 0; u < angularSegments; u++)
{
var i0 = (v * rowWidth) + u;
var i1 = i0 + 1;
var i2 = i0 + rowWidth;
var i3 = i2 + 1;
indices.Add(i0);
indices.Add(i2);
indices.Add(i1);
indices.Add(i1);
indices.Add(i2);
indices.Add(i3);
}
}
return new DisplayFaceMeshPatch(faceId, positions, normals, indices);
}
private static DisplayFaceMeshPatch CreateBoundedGridPatch(
FaceId faceId,
int angularSegments,
int axialSegments,
Func<double, double, Point3D> evaluate,
Func<double, double, Vector3D> evaluateNormal,
double uStart,
double uEnd,
double vStart,
double vEnd)
{
var positions = new List<Point3D>((angularSegments + 1) * (axialSegments + 1));
var normals = new List<Vector3D>((angularSegments + 1) * (axialSegments + 1));
var indices = new List<int>(angularSegments * axialSegments * 6);
for (var v = 0; v <= axialSegments; v++)
{
var tv = (double)v / axialSegments;
var vv = vStart + ((vEnd - vStart) * tv);
for (var u = 0; u <= angularSegments; u++)
{
var tu = (double)u / angularSegments;
var uu = uStart + ((uEnd - uStart) * tu);
positions.Add(evaluate(uu, vv));
normals.Add(evaluateNormal(uu, vv));
}
}
var rowWidth = angularSegments + 1;
for (var v = 0; v < axialSegments; v++)
{
for (var u = 0; u < angularSegments; u++)
{
var i0 = (v * rowWidth) + u;
var i1 = i0 + 1;
var i2 = i0 + rowWidth;
var i3 = i2 + 1;
indices.Add(i0);
indices.Add(i2);
indices.Add(i1);
indices.Add(i1);
indices.Add(i2);
indices.Add(i3);
}
}
return new DisplayFaceMeshPatch(faceId, positions, normals, indices);
}
private static KernelResult<(double UStart, double UEnd, double VStart, double VEnd)> TryResolveCylinderTrimPatch(
BrepBody body,
FaceId faceId,
CylinderSurface cylinder)
{
const double minSpan = 1e-8d;
const double nearFullWrapThreshold = 2d * double.Pi * 0.95d;
const double bridgeSeamGapMin = 8d * (double.Pi / 180d);
const double bridgeSeamGapMax = 12d * (double.Pi / 180d);
var loopIds = body.GetLoopIds(faceId);
if (loopIds.Count == 0)
{
return KernelResult<(double, double, double, double)>.Failure([
CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
}
var axis = cylinder.Axis.ToVector();
var xAxis = cylinder.XAxis.ToVector();
var yAxis = cylinder.YAxis.ToVector();
(double UStart, double USpan, double VStart, double VEnd, bool UsedAmbiguousShorterSpanResolution)? best = null;
(LoopId LoopId, int CoedgeCount, double AngularStart, double AngularSpan, double AxialSpan, bool IsNearFullWrap, bool AngularResolved, bool IsSingleCoedgeClosed, double VStart, bool HasBridgeTwin, SurfaceGeometryKind? TwinSurfaceKind)? bestAxialSpanDegenerate = null;
foreach (var loopId in loopIds)
{
var coedges = body.GetCoedgeIds(loopId).Select(id => body.Topology.GetCoedge(id)).ToArray();
var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
if (!vertexPointsResult.IsSuccess)
{
continue;
}
var allAngles = new List<double>();
var allAxials = new List<double>();
foreach (var coedge in coedges)
{
var endpoints = GetEdgeEndpoints(body, coedge.EdgeId, coedge.IsReversed, vertexPointsResult.Value);
if (!endpoints.IsSuccess)
{
allAngles.Clear();
break;
}
var start = endpoints.Value.Start;
var end = endpoints.Value.End;
allAngles.Add(CylinderAngleOf(cylinder, start, xAxis, yAxis, axis));
allAngles.Add(CylinderAngleOf(cylinder, end, xAxis, yAxis, axis));
allAxials.Add((start - cylinder.Origin).Dot(axis));
allAxials.Add((end - cylinder.Origin).Dot(axis));
var edgePolyline = TessellateEdge(body, coedge.EdgeId, DisplayTessellationOptions.Default);
if (!edgePolyline.IsSuccess)
{
continue;
}
var edgePoints = coedge.IsReversed
? edgePolyline.Value.Points.Reverse().ToArray()
: edgePolyline.Value.Points;
foreach (var point in edgePoints)
{
allAngles.Add(CylinderAngleOf(cylinder, point, xAxis, yAxis, axis));
allAxials.Add((point - cylinder.Origin).Dot(axis));
}
}
if (allAxials.Count == 0 || allAngles.Count == 0)
{
continue;
}
var vStart = allAxials.Min();
var vEnd = allAxials.Max();
var axialSpan = vEnd - vStart;
var angularBounds = ResolveAngularBounds(allAngles);
var angularSpan = (angularBounds.IsSuccess && angularBounds.Value.Span > minSpan) ? angularBounds.Value.Span : 0d;
if (axialSpan <= minSpan)
{
var isSingleCoedgeClosed = false;
var hasBridgeTwin = false;
SurfaceGeometryKind? twinSurfaceKind = null;
if (coedges.Length == 1 && body.TryGetEdgeVertices(coedges[0].EdgeId, out var edgeStart, out var edgeEnd))
{
isSingleCoedgeClosed = edgeStart == edgeEnd;
hasBridgeTwin = TryResolveBridgeTwinSurfaceKind(body, faceId, coedges[0].EdgeId, out twinSurfaceKind);
}
var degenerateCandidate = (
LoopId: loopId,
CoedgeCount: coedges.Length,
AngularStart: angularBounds.IsSuccess ? angularBounds.Value.Start : 0d,
AngularSpan: angularSpan,
AxialSpan: axialSpan,
IsNearFullWrap: angularBounds.IsSuccess && angularBounds.Value.Span >= nearFullWrapThreshold,
AngularResolved: angularBounds.IsSuccess && angularBounds.Value.Span > minSpan,
IsSingleCoedgeClosed: isSingleCoedgeClosed,
VStart: vStart,
HasBridgeTwin: hasBridgeTwin,
TwinSurfaceKind: twinSurfaceKind);
if (!bestAxialSpanDegenerate.HasValue ||
degenerateCandidate.AngularSpan > bestAxialSpanDegenerate.Value.AngularSpan ||
(System.Math.Abs(degenerateCandidate.AngularSpan - bestAxialSpanDegenerate.Value.AngularSpan) <= minSpan &&
degenerateCandidate.CoedgeCount > bestAxialSpanDegenerate.Value.CoedgeCount))
{
bestAxialSpanDegenerate = degenerateCandidate;
}
continue;
}
if (!angularBounds.IsSuccess || angularBounds.Value.Span <= minSpan)
{
continue;
}
var candidate = (UStart: angularBounds.Value.Start, USpan: angularBounds.Value.Span, VStart: vStart, VEnd: vEnd, angularBounds.Value.UsedAmbiguousShorterSpanResolution);
var candidateScore = candidate.USpan * (candidate.VEnd - candidate.VStart);
var bestScore = best.HasValue ? best.Value.USpan * (best.Value.VEnd - best.Value.VStart) : double.NegativeInfinity;
if (!best.HasValue || candidateScore > bestScore)
{
best = candidate;
}
}
if (!best.HasValue)
{
var dualCirclePatch = TryResolveDualSingleCoedgeClosedCircleCylinderTrimPatch(body, faceId, cylinder, loopIds, axis, minSpan);
if (dualCirclePatch.IsSuccess)
{
return dualCirclePatch;
}
if (bestAxialSpanDegenerate.HasValue && loopIds.Count == 1)
{
var isSingleCoedge = bestAxialSpanDegenerate.Value.CoedgeCount == 1;
var seamGap = (2d * double.Pi) - bestAxialSpanDegenerate.Value.AngularSpan;
var isBridgeFamily =
isSingleCoedge
&& bestAxialSpanDegenerate.Value.IsNearFullWrap
&& bestAxialSpanDegenerate.Value.AngularResolved
&& bestAxialSpanDegenerate.Value.AxialSpan <= minSpan
&& bestAxialSpanDegenerate.Value.IsSingleCoedgeClosed
&& seamGap >= bridgeSeamGapMin
&& seamGap <= bridgeSeamGapMax
&& bestAxialSpanDegenerate.Value.HasBridgeTwin
&& bestAxialSpanDegenerate.Value.TwinSurfaceKind is SurfaceGeometryKind.Plane or SurfaceGeometryKind.Cone or SurfaceGeometryKind.Torus;
if (isBridgeFamily)
{
return KernelResult<(double, double, double, double)>.Success(
(
bestAxialSpanDegenerate.Value.AngularStart,
bestAxialSpanDegenerate.Value.AngularStart + bestAxialSpanDegenerate.Value.AngularSpan,
bestAxialSpanDegenerate.Value.VStart,
bestAxialSpanDegenerate.Value.VStart),
[CreateValidationWarning(
$"Face {faceId.Value} cylindrical trim treated as zero-width bridge limit (loop {bestAxialSpanDegenerate.Value.LoopId.Value}, seam gap {seamGap * (180d / double.Pi):F3} deg, twin {bestAxialSpanDegenerate.Value.TwinSurfaceKind}).",
CylinderTrimAxialSpanDegenerateSingleCoedgeNearFullWrapBridgeSource)]);
}
var classification = bestAxialSpanDegenerate.Value.IsNearFullWrap
? isSingleCoedge
? bestAxialSpanDegenerate.Value.IsSingleCoedgeClosed
? "single-coedge closed ring-like near-full-wrap boundary with collapsed axial span"
: "single-coedge near-full-wrap boundary with collapsed axial span"
: "multi-coedge ring-like near-full-wrap boundary with collapsed axial span"
: bestAxialSpanDegenerate.Value.AngularResolved
? isSingleCoedge
? "single-coedge trimmed cylindrical loop with collapsed axial span"
: "multi-coedge trimmed cylindrical loop with collapsed axial span"
: "axial-span-collapsed loop without resolvable angular extent";
var diagnosticSource = bestAxialSpanDegenerate.Value.IsNearFullWrap
? isSingleCoedge
? CylinderTrimAxialSpanDegenerateSingleCoedgeNearFullWrapSource
: CylinderTrimAxialSpanDegenerateMultiCoedgeSource
: isSingleCoedge
? CylinderTrimAxialSpanDegenerateSingleCoedgeSource
: CylinderTrimAxialSpanDegenerateMultiCoedgeSource;
return KernelResult<(double, double, double, double)>.Failure([
CreateInvalidArgument(
$"Face {faceId.Value} cylindrical trim loop {bestAxialSpanDegenerate.Value.LoopId.Value} has {bestAxialSpanDegenerate.Value.CoedgeCount} coedges, angular span {bestAxialSpanDegenerate.Value.AngularSpan:R}, axial span {bestAxialSpanDegenerate.Value.AxialSpan:R}, loop count {loopIds.Count}; classified as {classification} and treated as degenerate.",
diagnosticSource)]);
}
return KernelResult<(double, double, double, double)>.Failure([
CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
}
var diagnostics = new List<KernelDiagnostic>();
if (best.Value.UsedAmbiguousShorterSpanResolution)
{
diagnostics.Add(CreateValidationWarning(
"Cylindrical face tessellation resolved ambiguous trim by choosing the shorter angular span.",
CylinderTrimAmbiguousUsedShorterSpanSource));
}
return KernelResult<(double, double, double, double)>.Success(
(best.Value.UStart, best.Value.UStart + best.Value.USpan, best.Value.VStart, best.Value.VEnd),
diagnostics);
}
private static KernelResult<(double UStart, double UEnd, double VStart, double VEnd)> TryResolveDualSingleCoedgeClosedCircleCylinderTrimPatch(
BrepBody body,
FaceId faceId,
CylinderSurface cylinder,
IReadOnlyList<LoopId> loopIds,
Vector3D axis,
double minSpan)
{
const double fullWrapTolerance = 1e-3d;
const double axisAlignmentTolerance = 1e-4d;
const double centerAxisOffsetTolerance = 1e-4d;
const double radiusTolerance = 1e-4d;
if (loopIds.Count != 2)
{
return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
}
var loops = new List<(LoopId LoopId, EdgeId EdgeId, double AxialCenter)>();
foreach (var loopId in loopIds)
{
var coedgeIds = body.GetCoedgeIds(loopId);
if (coedgeIds.Count != 1)
{
return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
}
var coedge = body.Topology.GetCoedge(coedgeIds[0]);
var curve = body.GetEdgeCurve(coedge.EdgeId);
if (curve.Kind != CurveGeometryKind.Circle3)
{
return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
}
if (!body.TryGetEdgeVertices(coedge.EdgeId, out var startVertexId, out var endVertexId) || startVertexId != endVertexId)
{
return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
}
if (!body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var edgeBinding)
|| edgeBinding.TrimInterval is not ParameterInterval trimInterval
|| !double.IsFinite(trimInterval.Start)
|| !double.IsFinite(trimInterval.End)
|| double.Abs((trimInterval.End - trimInterval.Start) - (2d * double.Pi)) > fullWrapTolerance)
{
return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
}
var circle = curve.Circle3!.Value;
var axisDot = circle.Normal.ToVector().Dot(cylinder.Axis.ToVector());
if (double.Abs(double.Abs(axisDot) - 1d) > axisAlignmentTolerance)
{
return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
}
var centerOffset = circle.Center - cylinder.Origin;
var axialCenter = centerOffset.Dot(axis);
var radialOffset = (centerOffset - (axis * axialCenter)).Length;
if (radialOffset > (cylinder.Radius * centerAxisOffsetTolerance))
{
return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
}
if (double.Abs(circle.Radius - cylinder.Radius) > (cylinder.Radius * radiusTolerance))
{
return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
}
loops.Add((loopId, coedge.EdgeId, axialCenter));
}
var first = loops[0];
var second = loops[1];
var vStart = System.Math.Min(first.AxialCenter, second.AxialCenter);
var vEnd = System.Math.Max(first.AxialCenter, second.AxialCenter);
var axialSpan = vEnd - vStart;
if (axialSpan <= minSpan)
{
return KernelResult<(double, double, double, double)>.Failure(Array.Empty<KernelDiagnostic>());
}
return KernelResult<(double, double, double, double)>.Success(
(0d, 2d * double.Pi, vStart, vEnd),
[CreateValidationWarning(
$"Face {faceId.Value} cylindrical trim classified as dual single-coedge closed-circle loops with zero per-loop axial span and center axial separation {axialSpan:R} (loops {first.LoopId.Value}/{second.LoopId.Value}, edges {first.EdgeId.Value}/{second.EdgeId.Value}).",
CylinderTrimDualSingleCoedgeClosedCircleSource)]);
}
private static bool TryResolveBridgeTwinSurfaceKind(BrepBody body, FaceId sourceFaceId, EdgeId edgeId, out SurfaceGeometryKind? twinSurfaceKind)
{
twinSurfaceKind = null;
var uses = new HashSet<FaceId>();
foreach (var face in body.Topology.Faces)
{
foreach (var loopId in face.LoopIds)
{
var coedgeIds = body.GetCoedgeIds(loopId);
foreach (var coedgeId in coedgeIds)
{
var coedge = body.Topology.GetCoedge(coedgeId);
if (coedge.EdgeId == edgeId)
{
uses.Add(face.Id);
break;
}
}
}
}
if (uses.Count != 2)
{
return false;
}
var useArray = uses.ToArray();
var twinFaceId = useArray[0] == sourceFaceId ? useArray[1] : useArray[0];
if (twinFaceId == sourceFaceId)
{
return false;
}
if (!body.TryGetFaceSurfaceGeometry(twinFaceId, out var twinSurface) || twinSurface is null)
{
return false;
}
twinSurfaceKind = twinSurface.Kind;
return true;
}
private static double CylinderAngleOf(CylinderSurface cylinder, Point3D point, Vector3D xAxis, Vector3D yAxis, Vector3D axis)
{
var offset = point - cylinder.Origin;
var axial = axis * offset.Dot(axis);
var radial = offset - axial;
return NormalizeToZeroTwoPi(double.Atan2(radial.Dot(yAxis), radial.Dot(xAxis)));
}
private static KernelResult<(double Start, double Span, bool UsedAmbiguousShorterSpanResolution)> ResolveAngularBounds(IReadOnlyList<double> rawAngles)
{
const double epsilon = 1e-8d;
var angles = rawAngles
.Select(NormalizeToZeroTwoPi)
.OrderBy(a => a)
.ToArray();
if (angles.Length == 0)
{
return KernelResult<(double, double, bool)>.Failure([CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
}
var largestGap = -1d;
var largestGapIndex = -1;
for (var i = 0; i < angles.Length; i++)
{
var current = angles[i];
var next = i == angles.Length - 1 ? angles[0] + (2d * double.Pi) : angles[i + 1];
var gap = next - current;
if (gap > largestGap + epsilon)
{
largestGap = gap;
largestGapIndex = i;
}
}
if (largestGapIndex < 0)
{
return KernelResult<(double, double, bool)>.Failure([CreateInvalidArgument("Cylindrical face tessellation derived a degenerate trim patch.", CylinderTrimDegenerateSource)]);
}
var usedAmbiguous = largestGap <= epsilon;
var start = angles[(largestGapIndex + 1) % angles.Length];
var span = (2d * double.Pi) - largestGap;
return KernelResult<(double, double, bool)>.Success((start, span, usedAmbiguous));
}
private static DisplayFaceMeshPatch CreatePlanarPatch(FaceId faceId, IReadOnlyList<Point3D> polygonPoints, Vector3D normal, IReadOnlyList<int> triangleIndices)
{
var normals = Enumerable.Repeat(normal, polygonPoints.Count).ToArray();
return new DisplayFaceMeshPatch(faceId, polygonPoints.ToArray(), normals, triangleIndices.ToArray());
}
private static DisplayFaceMeshPatch CreateEmptyPlanarPatch(FaceId faceId)
=> new(faceId, Array.Empty<Point3D>(), Array.Empty<Vector3D>(), Array.Empty<int>());
private static KernelResult<IReadOnlyList<Point3D>> BuildFlattenedPlanarLoopPoints(
BrepBody body,
IReadOnlyList<Coedge> coedges,
FaceId faceId,
PlaneSurface plane,
DisplayTessellationOptions options)
{
var vertexPointsResult = BuildLoopVertexPointLookup(body, coedges, faceId);
if (!vertexPointsResult.IsSuccess)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure(vertexPointsResult.Diagnostics);
}
var vertexPoints = vertexPointsResult.Value;
var orientedEndpoints = new List<(Point3D Start, Point3D End)>(coedges.Count);
foreach (var coedge in coedges)
{
var endpoints = GetEdgeEndpoints(body, coedge.EdgeId, coedge.IsReversed, vertexPoints);
if (!endpoints.IsSuccess)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure(endpoints.Diagnostics);
}
orientedEndpoints.Add(endpoints.Value);
}
var orderedIndices = new List<int>(coedges.Count) { 0 };
var chainedEndpoints = new List<(Point3D Start, Point3D End)>(coedges.Count) { orientedEndpoints[0] };
var traversalSwapped = new List<bool>(coedges.Count) { false };
var used = new bool[coedges.Count];
used[0] = true;
var currentEnd = orientedEndpoints[0].End;
for (var step = 1; step < coedges.Count; step++)
{
var nextIndex = FindNextCoedgeIndex(orientedEndpoints, used, currentEnd, out var nextStart, out var nextEnd, out var swapped);
if (nextIndex < 0)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure([CreateInvalidArgument($"Face {faceId.Value} planar loop coedges do not form a contiguous chain.", PlanarCurveFlatteningFailedSource)]);
}
used[nextIndex] = true;
orderedIndices.Add(nextIndex);
chainedEndpoints.Add((nextStart, nextEnd));
traversalSwapped.Add(swapped);
currentEnd = nextEnd;
}
if (!PointsAlmostEqual(chainedEndpoints[0].Start, currentEnd))
{
return KernelResult<IReadOnlyList<Point3D>>.Failure([CreateInvalidArgument($"Face {faceId.Value} planar loop coedges did not close after chaining.", PlanarCurveFlatteningFailedSource)]);
}
var flattened = new List<Point3D>();
AppendUniquePoint(flattened, chainedEndpoints[0].Start);
for (var chainIndex = 0; chainIndex < orderedIndices.Count; chainIndex++)
{
var index = orderedIndices[chainIndex];
var coedge = coedges[index];
var (segmentStart, segmentEnd) = chainedEndpoints[chainIndex];
var isTraversalSwapped = traversalSwapped[chainIndex];
var curve = body.GetEdgeCurve(coedge.EdgeId);
switch (curve.Kind)
{
case CurveGeometryKind.Line3:
AppendUniquePoint(flattened, segmentEnd);
break;
case CurveGeometryKind.Circle3:
var arcPointsResult = SampleCircleArc(body, coedge, isTraversalSwapped, curve.Circle3!.Value, segmentStart, segmentEnd, plane, faceId, options);
if (!arcPointsResult.IsSuccess)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure(arcPointsResult.Diagnostics);
}
foreach (var point in arcPointsResult.Value)
{
AppendUniquePoint(flattened, point);
}
break;
case CurveGeometryKind.BSpline3:
var splinePointsResult = SamplePlanarBSpline(body, coedge, isTraversalSwapped, curve.BSpline3!.Value, segmentStart, segmentEnd);
if (!splinePointsResult.IsSuccess)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure(splinePointsResult.Diagnostics);
}
foreach (var point in splinePointsResult.Value)
{
AppendUniquePoint(flattened, point);
}
break;
case CurveGeometryKind.Ellipse3:
var ellipsePointsResult = SamplePlanarEllipse(body, coedge, isTraversalSwapped, curve.Ellipse3!.Value, segmentStart, segmentEnd, plane, faceId, options);
if (!ellipsePointsResult.IsSuccess)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure(ellipsePointsResult.Diagnostics);
}
foreach (var point in ellipsePointsResult.Value)
{
AppendUniquePoint(flattened, point);
}
break;
case CurveGeometryKind.Hyperbola3:
var hyperbolaPointsResult = SamplePlanarHyperbola(body, coedge, isTraversalSwapped, curve.Hyperbola3!.Value, segmentStart, segmentEnd, plane, faceId, options);
if (!hyperbolaPointsResult.IsSuccess)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure(hyperbolaPointsResult.Diagnostics);
}
foreach (var point in hyperbolaPointsResult.Value)
{
AppendUniquePoint(flattened, point);
}
break;
default:
var curveKind = curve.UnsupportedKind ?? curve.Kind.ToString();
return KernelResult<IReadOnlyList<Point3D>>.Failure([
CreateNotImplemented($"Face {faceId.Value} planar curve flattening does not support curve kind '{curveKind}'.", PlanarCurveFlatteningUnsupportedSource)]);
}
}
if (flattened.Count > 1 && PointsAlmostEqual(flattened[0], flattened[^1]))
{
flattened.RemoveAt(flattened.Count - 1);
}
return KernelResult<IReadOnlyList<Point3D>>.Success(flattened);
}
private static KernelResult<IReadOnlyList<Point3D>> SampleCircleArc(
BrepBody body,
Coedge coedge,
bool traversalSwapped,
Circle3Curve circle,
Point3D start,
Point3D end,
PlaneSurface plane,
FaceId faceId,
DisplayTessellationOptions options)
{
var effectiveIsReversed = coedge.IsReversed ^ traversalSwapped;
if (body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var binding)
&& CurveSampler.TrySampleTrimmedCircleArc(
circle,
start,
end,
effectiveIsReversed ? !binding.OrientedEdgeSense : binding.OrientedEdgeSense,
out var sampledPoints,
out var isClosed,
out var usedShorterArcFallback,
options))
{
var points = new List<Point3D>(sampledPoints.Count - 1);
for (var i = 1; i < sampledPoints.Count; i++)
{
points.Add(sampledPoints[i]);
}
if (!isClosed)
{
points[^1] = end;
}
if (usedShorterArcFallback)
{
return KernelResult<IReadOnlyList<Point3D>>.Success(
points,
[CreateValidationWarning($"Face {faceId.Value} edge {coedge.EdgeId.Value} circular planar trim was ambiguous; using shorter arc.", CircleTrimAmbiguousUsedShorterArcSource)]);
}
return KernelResult<IReadOnlyList<Point3D>>.Success(points);
}
var deltaResult = ResolveArcDelta(body, coedge, traversalSwapped, circle, start, end, plane, faceId);
if (!deltaResult.IsSuccess)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure(deltaResult.Diagnostics);
}
var (startAngle, delta) = deltaResult.Value;
var samples = CurveSampler.SampleCircleArc(circle, startAngle, delta, options);
var pointsFallback = new List<Point3D>(samples.Count - 1);
for (var i = 1; i < samples.Count; i++)
{
pointsFallback.Add(samples[i]);
}
return KernelResult<IReadOnlyList<Point3D>>.Success(pointsFallback);
}
/// <summary>
/// Cuts an open sampled polyline at the points nearest to <paramref name="start"/> and <paramref name="end"/>,
/// returning the portion between them in start-to-end order, or null when that is ambiguous or degenerate.
/// </summary>
private static Point3D[]? TrimPolylineBetween(Point3D[] samples, Point3D start, Point3D end)
{
if (samples.Length < 2)
{
return null;
}
static (int Segment, double T, double Distance) Locate(Point3D[] points, Point3D target)
{
var best = (Segment: 0, T: 0d, Distance: double.PositiveInfinity);
for (var i = 0; i + 1 < points.Length; i++)
{
var edge = points[i + 1] - points[i];
var lengthSquared = edge.Dot(edge);
var t = lengthSquared <= 0d ? 0d : double.Clamp((target - points[i]).Dot(edge) / lengthSquared, 0d, 1d);
var closest = points[i] + (edge * t);
var distance = (target - closest).Length;
if (distance < best.Distance)
{
best = (i, t, distance);
}
}
return best;
}
var startLocation = Locate(samples, start);
var endLocation = Locate(samples, end);
const double locateTolerance = 5e-2d;
if (startLocation.Distance > locateTolerance || endLocation.Distance > locateTolerance)
{
return null;
}
var startPosition = startLocation.Segment + startLocation.T;
var endPosition = endLocation.Segment + endLocation.T;
if (double.Abs(endPosition - startPosition) < 1e-9d)
{
return null;
}
var forward = startPosition < endPosition;
var lowPosition = forward ? startPosition : endPosition;
var highPosition = forward ? endPosition : startPosition;
var slice = new List<Point3D>();
var firstWhole = (int)double.Floor(lowPosition) + 1;
var lastWhole = (int)double.Ceiling(highPosition) - 1;
for (var i = firstWhole; i <= lastWhole && i < samples.Length; i++)
{
slice.Add(samples[i]);
}
slice.Insert(0, start);
slice.Add(end);
if (!forward)
{
// slice is currently [start, interior (ascending), end]; interior must run from start toward end.
var interior = slice.Skip(1).Take(slice.Count - 2).Reverse().ToList();
slice = [start, .. interior, end];
}
return slice.Count >= 2 ? slice.ToArray() : null;
}
private static KernelResult<IReadOnlyList<Point3D>> SamplePlanarBSpline(
BrepBody body,
Coedge coedge,
bool traversalSwapped,
BSpline3Curve spline,
Point3D start,
Point3D end)
{
var interval = new ParameterInterval(spline.DomainStart, spline.DomainEnd);
var reverseSampleOrder = false;
var effectiveIsReversed = coedge.IsReversed ^ traversalSwapped;
if (body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var binding) && binding.TrimInterval is ParameterInterval trim)
{
interval = trim;
reverseSampleOrder = effectiveIsReversed ^ !binding.OrientedEdgeSense;
}
else
{
reverseSampleOrder = effectiveIsReversed;
}
var sampled = CurveSampler.SampleBSpline(spline, interval).ToArray();
if (reverseSampleOrder)
{
Array.Reverse(sampled);
}
if (sampled.Length < 2)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure([
CreateInvalidArgument($"Edge {coedge.EdgeId.Value} planar BSpline flattening produced an invalid sample set.", PlanarCurveFlatteningFailedSource)]);
}
// Orientation flags (coedge sense, edge sense, chain swap) can disagree with the curve's own parameter
// direction. The snap below would then pin the wrong ends and leave a spike that self-intersects the loop,
// so let the geometry have the last word for open curves.
var forwardMisfit = (sampled[0] - start).Length + (sampled[^1] - end).Length;
var reversedMisfit = (sampled[^1] - start).Length + (sampled[0] - end).Length;
if (reversedMisfit + 1e-9d < forwardMisfit)
{
Array.Reverse(sampled);
}
if (System.Math.Min(forwardMisfit, reversedMisfit) > 1e-3d
&& TrimPolylineBetween(sampled, start, end) is { } trimmed)
{
// The edge only covers part of its B-spline curve and no trim interval was recorded, so sampling the
// whole domain and snapping the ends would spike across the loop. Cut the polyline at the vertices.
sampled = trimmed;
}
sampled[0] = start;
sampled[^1] = end;
var points = new List<Point3D>(sampled.Length - 1);
for (var i = 1; i < sampled.Length; i++)
{
points.Add(sampled[i]);
}
return KernelResult<IReadOnlyList<Point3D>>.Success(points);
}
private static KernelResult<IReadOnlyList<Point3D>> SamplePlanarEllipse(
BrepBody body,
Coedge coedge,
bool traversalSwapped,
Ellipse3Curve ellipse,
Point3D start,
Point3D end,
PlaneSurface plane,
FaceId faceId,
DisplayTessellationOptions options)
{
const double planeContainmentTolerance = 1e-7d;
var normalAlignment = double.Abs(ellipse.Normal.ToVector().Dot(plane.Normal.ToVector()));
var centerOffset = double.Abs((ellipse.Center - plane.Origin).Dot(plane.Normal.ToVector()));
if (normalAlignment < 1d - 1e-7d || centerOffset > planeContainmentTolerance)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure([
CreateNotImplemented($"Face {faceId.Value} edge {coedge.EdgeId.Value} planar ellipse flattening requires the ellipse plane to match the face plane.", PlanarCurveFlatteningUnsupportedSource)]);
}
var trimResult = ResolvePlanarEllipseTrim(body, coedge, traversalSwapped, ellipse, start, end, plane, faceId);
if (!trimResult.IsSuccess)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure(trimResult.Diagnostics);
}
var (trimStart, trimDelta) = trimResult.Value;
var segmentCount = ComputeEllipseSegmentCount(ellipse, trimStart, trimStart + trimDelta, options);
var sampled = Enumerable.Range(0, segmentCount + 1)
.Select(i => ellipse.Evaluate(trimStart + trimDelta * i / segmentCount)).ToArray();
sampled[0] = start;
sampled[^1] = end;
var points = new List<Point3D>(sampled.Length - 1);
for (var i = 1; i < sampled.Length; i++)
{
points.Add(sampled[i]);
}
return KernelResult<IReadOnlyList<Point3D>>.Success(points);
}
// A start parameter and a signed sweep, as for planar circles: a coedge used against its edge
// walks the trim backwards, which an increasing ParameterInterval cannot express.
private static KernelResult<(double Start, double Delta)> ResolvePlanarEllipseTrim(
BrepBody body,
Coedge coedge,
bool traversalSwapped,
Ellipse3Curve ellipse,
Point3D start,
Point3D end,
PlaneSurface plane,
FaceId faceId)
{
if (body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var binding) && binding.TrimInterval is ParameterInterval trim)
{
var effectiveIsReversed = coedge.IsReversed ^ traversalSwapped ^ !binding.OrientedEdgeSense;
var trimStart = effectiveIsReversed ? trim.End : trim.Start;
var trimDelta = (effectiveIsReversed ? trim.Start : trim.End) - trimStart;
if (double.IsFinite(trimDelta) && double.Abs(trimDelta) > 1e-9d)
return KernelResult<(double, double)>.Success((trimStart, trimDelta));
}
var startAngle = AngleOnEllipse(ellipse, start);
var endAngle = AngleOnEllipse(ellipse, end);
var delta = NormalizeToSignedPi(endAngle - startAngle);
if (double.Abs(delta) < 1e-9d)
{
return KernelResult<(double, double)>.Failure([
CreateInvalidArgument($"Face {faceId.Value} planar ellipse flattening detected a degenerate ellipse trim.", PlanarCurveFlatteningFailedSource)]);
}
var orientation = ellipse.Normal.ToVector().Dot(plane.Normal.ToVector());
if (orientation < 0d)
{
delta = -delta;
}
return KernelResult<(double, double)>.Success((startAngle, delta));
}
private static KernelResult<(double StartAngle, double Delta)> ResolveArcDelta(
BrepBody body,
Coedge coedge,
bool traversalSwapped,
Circle3Curve circle,
Point3D start,
Point3D end,
PlaneSurface plane,
FaceId faceId)
{
var startAngle = AngleOnCircle(circle, start);
var endAngle = AngleOnCircle(circle, end);
if (body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var binding) && binding.TrimInterval is ParameterInterval trim)
{
var effectiveIsReversed = coedge.IsReversed ^ traversalSwapped ^ !binding.OrientedEdgeSense;
var trimStart = effectiveIsReversed ? trim.End : trim.Start;
var trimEnd = effectiveIsReversed ? trim.Start : trim.End;
var trimDelta = trimEnd - trimStart;
if (double.IsFinite(trimDelta) && double.Abs(trimDelta) > 1e-9d)
{
return KernelResult<(double, double)>.Success((trimStart, trimDelta));
}
}
var delta = NormalizeToSignedPi(endAngle - startAngle);
if (double.Abs(delta) < 1e-9d)
{
return KernelResult<(double, double)>.Failure([
CreateInvalidArgument($"Face {faceId.Value} planar arc flattening detected a degenerate circle arc.", PlanarCurveFlatteningFailedSource)]);
}
var orientation = circle.Normal.ToVector().Dot(plane.Normal.ToVector());
if (orientation < 0d)
{
delta = -delta;
}
return KernelResult<(double, double)>.Success((startAngle, delta));
}
private static double AngleOnCircle(Circle3Curve circle, Point3D point)
{
var offset = point - circle.Center;
var x = offset.Dot(circle.XAxis.ToVector());
var y = offset.Dot(circle.YAxis.ToVector());
return double.Atan2(y, x);
}
private static double AngleOnEllipse(Ellipse3Curve ellipse, Point3D point)
{
var offset = point - ellipse.Center;
var x = offset.Dot(ellipse.XAxis.ToVector()) / ellipse.MajorRadius;
var y = offset.Dot(ellipse.YAxis.ToVector()) / ellipse.MinorRadius;
return double.Atan2(y, x);
}
private static double NormalizeToSignedPi(double angle)
{
while (angle <= -double.Pi)
{
angle += 2d * double.Pi;
}
while (angle > double.Pi)
{
angle -= 2d * double.Pi;
}
return angle;
}
private static double TorusMinorAngleOf(TorusSurface torus, Point3D point)
{
var offset = point - torus.Center;
var x = offset.Dot(torus.XAxis.ToVector());
var y = offset.Dot(torus.YAxis.ToVector());
var u = NormalizeToZeroTwoPi(double.Atan2(y, x));
var majorDirection = (torus.XAxis.ToVector() * double.Cos(u)) + (torus.YAxis.ToVector() * double.Sin(u));
var radialFromMajorCircle = offset.Dot(majorDirection) - torus.MajorRadius;
var axial = offset.Dot(torus.Axis.ToVector());
return NormalizeToZeroTwoPi(double.Atan2(axial, radialFromMajorCircle));
}
private static double NormalizeToZeroTwoPi(double angle)
{
var twoPi = 2d * double.Pi;
var normalized = angle % twoPi;
if (normalized < 0d)
{
normalized += twoPi;
}
return normalized;
}
private static int FindNextCoedgeIndex(
IReadOnlyList<(Point3D Start, Point3D End)> endpoints,
IReadOnlyList<bool> used,
Point3D currentEnd,
out Point3D nextStart,
out Point3D nextEnd,
out bool swapped)
{
var matchIndex = -1;
nextStart = default;
nextEnd = default;
swapped = false;
for (var i = 0; i < endpoints.Count; i++)
{
if (used[i])
{
continue;
}
var (start, end) = endpoints[i];
if (PointsAlmostEqual(start, currentEnd))
{
matchIndex = i;
nextStart = start;
nextEnd = end;
swapped = false;
break;
}
if (PointsAlmostEqual(end, currentEnd))
{
matchIndex = i;
nextStart = end;
nextEnd = start;
swapped = true;
break;
}
}
return matchIndex;
}
private static void AppendUniquePoint(List<Point3D> points, Point3D point)
{
if (points.Count == 0)
{
points.Add(point);
return;
}
if (!PointsAlmostEqual(points[^1], point))
{
points.Add(point);
}
}
private static bool PointsAlmostEqual(Point3D left, Point3D right)
=> (left - right).LengthSquared <= (LoopEndpointTolerance * LoopEndpointTolerance);
private static KernelResult<DisplayEdgePolyline> TessellateEdge(BrepBody body, EdgeId edgeId, DisplayTessellationOptions options)
{
if (!body.TryGetEdgeCurveGeometry(edgeId, out var curve) || curve is null)
{
return KernelResult<DisplayEdgePolyline>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing bound curve geometry.")]);
}
if (!body.Bindings.TryGetEdgeBinding(edgeId, out var binding))
{
return KernelResult<DisplayEdgePolyline>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing curve binding.")]);
}
var interval = binding.TrimInterval ?? new ParameterInterval(0d, 1d);
switch (curve.Kind)
{
case CurveGeometryKind.Line3:
var line = curve.Line3!.Value;
return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(
edgeId,
CurveSampler.SampleLine(line, interval),
IsClosed: false));
case CurveGeometryKind.Circle3:
var circle = curve.Circle3!.Value;
var startPointResult = EvaluateEdgeEndpoint(body, edgeId, useStart: true);
if (!startPointResult.IsSuccess)
{
return KernelResult<DisplayEdgePolyline>.Failure(startPointResult.Diagnostics);
}
var endPointResult = EvaluateEdgeEndpoint(body, edgeId, useStart: false);
if (!endPointResult.IsSuccess)
{
return KernelResult<DisplayEdgePolyline>.Failure(endPointResult.Diagnostics);
}
if (!CurveSampler.TrySampleTrimmedCircleArc(
circle,
startPointResult.Value,
endPointResult.Value,
binding.OrientedEdgeSense,
out var points,
out var isClosed,
out var usedShorterArcFallback))
{
return KernelResult<DisplayEdgePolyline>.Failure([
CreateInvalidArgument($"Edge {edgeId.Value} failed to resolve circle trim from edge endpoints.", CircleTrimResolveFailedSource)]);
}
if (usedShorterArcFallback)
{
return KernelResult<DisplayEdgePolyline>.Success(
new DisplayEdgePolyline(edgeId, points, isClosed),
[CreateValidationWarning($"Edge {edgeId.Value} circular trim was ambiguous; using shorter arc.", CircleTrimAmbiguousUsedShorterArcSource)]);
}
return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(edgeId, points, isClosed));
case CurveGeometryKind.BSpline3:
var spline = curve.BSpline3!.Value;
return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(
edgeId,
CurveSampler.SampleBSpline(spline, interval),
IsClosed: false));
case CurveGeometryKind.Ellipse3:
var ellipse = curve.Ellipse3!.Value;
var segments = ComputeEllipseSegmentCount(ellipse, interval.Start, interval.End, options);
return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(
edgeId,
SampleEllipseCurve(ellipse, interval, segments),
IsClosed: false));
case CurveGeometryKind.Hyperbola3:
var hyperbola = curve.Hyperbola3!.Value;
return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(
edgeId,
SampleHyperbolaCurve(hyperbola, interval, options),
IsClosed: false));
default:
return KernelResult<DisplayEdgePolyline>.Failure([CreateNotImplemented($"Edge {edgeId.Value} has unsupported curve kind '{curve.Kind}'.")]);
}
}
private static KernelResult<Dictionary<VertexId, Point3D>> BuildLoopVertexPointLookup(BrepBody body, IReadOnlyList<Coedge> coedges, FaceId faceId)
{
var requiredVertexIds = new HashSet<VertexId>();
foreach (var coedge in coedges)
{
if (!body.TryGetEdgeVertices(coedge.EdgeId, out var startVertexId, out var endVertexId))
{
return KernelResult<Dictionary<VertexId, Point3D>>.Failure([CreateNotImplemented($"Face {faceId.Value} references missing edge topology for edge {coedge.EdgeId.Value}.")]);
}
requiredVertexIds.Add(startVertexId);
requiredVertexIds.Add(endVertexId);
}
var vertexPoints = new Dictionary<VertexId, Point3D>();
foreach (var vertexId in requiredVertexIds.OrderBy(v => v.Value))
{
var pointResult = GetVertexPoint(body, vertexId);
if (!pointResult.IsSuccess)
{
return KernelResult<Dictionary<VertexId, Point3D>>.Failure(pointResult.Diagnostics);
}
vertexPoints[vertexId] = pointResult.Value;
}
return KernelResult<Dictionary<VertexId, Point3D>>.Success(vertexPoints);
}
private static KernelResult<Point3D> GetVertexPoint(BrepBody body, VertexId vertexId)
{
if (body.TryGetVertexPoint(vertexId, out var point))
{
return KernelResult<Point3D>.Success(point);
}
foreach (var edge in body.Topology.Edges.OrderBy(e => e.Id.Value))
{
if (edge.StartVertexId != vertexId)
{
continue;
}
var edgePoint = EvaluateEdgeEndpointFromTopologyTrim(body, edge.Id, useStart: true);
if (edgePoint.IsSuccess)
{
return KernelResult<Point3D>.Success(edgePoint.Value);
}
}
foreach (var edge in body.Topology.Edges.OrderBy(e => e.Id.Value))
{
if (edge.EndVertexId != vertexId)
{
continue;
}
var edgePoint = EvaluateEdgeEndpointFromTopologyTrim(body, edge.Id, useStart: false);
if (edgePoint.IsSuccess)
{
return KernelResult<Point3D>.Success(edgePoint.Value);
}
}
return KernelResult<Point3D>.Failure([CreateNotImplemented($"Vertex {vertexId.Value} cannot be resolved to a geometric point for tessellation.")]);
}
private static KernelResult<Point3D> EvaluateEdgeEndpointFromTopologyTrim(BrepBody body, EdgeId edgeId, bool useStart)
{
if (!body.TryGetEdgeCurveGeometry(edgeId, out var curve) || curve is null)
{
return KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing bound curve geometry.")]);
}
if (!body.Bindings.TryGetEdgeBinding(edgeId, out var binding))
{
return KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing curve binding.")]);
}
var interval = binding.TrimInterval ?? new ParameterInterval(0d, 1d);
var parameter = useStart ? interval.Start : interval.End;
return curve.Kind switch
{
CurveGeometryKind.Line3 => KernelResult<Point3D>.Success(curve.Line3!.Value.Evaluate(parameter)),
CurveGeometryKind.Circle3 => KernelResult<Point3D>.Success(curve.Circle3!.Value.Evaluate(parameter)),
CurveGeometryKind.BSpline3 => KernelResult<Point3D>.Success(curve.BSpline3!.Value.Evaluate(parameter)),
CurveGeometryKind.Ellipse3 => KernelResult<Point3D>.Success(curve.Ellipse3!.Value.Evaluate(parameter)),
CurveGeometryKind.Hyperbola3 => KernelResult<Point3D>.Success(curve.Hyperbola3!.Value.Evaluate(parameter)),
_ => KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} endpoint evaluation does not support curve kind '{curve.UnsupportedKind ?? curve.Kind.ToString()}'.", PlanarCurveFlatteningUnsupportedSource)]),
};
}
private static KernelResult<Point3D> EvaluateEdgeEndpoint(BrepBody body, EdgeId edgeId, bool useStart)
{
if (!body.TryGetEdgeCurveGeometry(edgeId, out var curve) || curve is null)
{
return KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing bound curve geometry.")]);
}
if (!body.Bindings.TryGetEdgeBinding(edgeId, out var binding))
{
return KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing curve binding.")]);
}
var interval = binding.TrimInterval ?? new ParameterInterval(0d, 1d);
var useTrimStart = useStart == binding.OrientedEdgeSense;
var parameter = useTrimStart ? interval.Start : interval.End;
return curve.Kind switch
{
CurveGeometryKind.Line3 => KernelResult<Point3D>.Success(curve.Line3!.Value.Evaluate(parameter)),
CurveGeometryKind.Circle3 => KernelResult<Point3D>.Success(curve.Circle3!.Value.Evaluate(parameter)),
CurveGeometryKind.BSpline3 => KernelResult<Point3D>.Success(curve.BSpline3!.Value.Evaluate(parameter)),
CurveGeometryKind.Ellipse3 => KernelResult<Point3D>.Success(curve.Ellipse3!.Value.Evaluate(parameter)),
CurveGeometryKind.Hyperbola3 => KernelResult<Point3D>.Success(curve.Hyperbola3!.Value.Evaluate(parameter)),
_ => KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} endpoint evaluation does not support curve kind '{curve.UnsupportedKind ?? curve.Kind.ToString()}'.", PlanarCurveFlatteningUnsupportedSource)]),
};
}
private static KernelResult<(Point3D Start, Point3D End)> GetEdgeEndpoints(
BrepBody body,
EdgeId edgeId,
bool reversed,
IReadOnlyDictionary<VertexId, Point3D> vertexPoints)
{
if (!body.TryGetEdgeVertices(edgeId, out var startVertexId, out var endVertexId))
{
return KernelResult<(Point3D, Point3D)>.Failure([CreateNotImplemented($"Edge {edgeId.Value} is missing topology endpoints.")]);
}
if (!vertexPoints.TryGetValue(startVertexId, out var start) || !vertexPoints.TryGetValue(endVertexId, out var end))
{
return KernelResult<(Point3D, Point3D)>.Failure([CreateNotImplemented($"Edge {edgeId.Value} references unresolved vertex points.")]);
}
return KernelResult<(Point3D, Point3D)>.Success(reversed ? (end, start) : (start, end));
}
private static IReadOnlyList<Point3D> SampleEllipseCurve(Ellipse3Curve ellipse, ParameterInterval trim, int segmentCount)
{
var points = new List<Point3D>(segmentCount + 1);
var step = (trim.End - trim.Start) / segmentCount;
for (var i = 0; i <= segmentCount; i++)
{
points.Add(ellipse.Evaluate(trim.Start + (step * i)));
}
return points;
}
private static int ComputeEllipseSegmentCount(Ellipse3Curve ellipse, double start, double end, DisplayTessellationOptions options)
{
// An ellipse is an affine image of the unit circle. Its major radius
// bounds chord sag; a/b bounds tangent turning per parameter radian.
// The old fixed 45-degree step ignored both caller budgets and left
// only two chords on a quarter-ellipse fillet miter.
return CalculateSegmentCount(double.Abs(end - start), ellipse.MajorRadius,
options with { AngularToleranceRadians = options.AngularToleranceRadians * ellipse.MinorRadius / ellipse.MajorRadius });
}
private static KernelResult<IReadOnlyList<Point3D>> SamplePlanarHyperbola(
BrepBody body,
Coedge coedge,
bool traversalSwapped,
Hyperbola3Curve hyperbola,
Point3D start,
Point3D end,
PlaneSurface plane,
FaceId faceId,
DisplayTessellationOptions options)
{
const double planeContainmentTolerance = 1e-7d;
var normalAlignment = double.Abs(hyperbola.PlaneNormal.ToVector().Dot(plane.Normal.ToVector()));
var centerOffset = double.Abs((hyperbola.Center - plane.Origin).Dot(plane.Normal.ToVector()));
if (normalAlignment < 1d - 1e-7d || centerOffset > planeContainmentTolerance)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure([
CreateNotImplemented($"Face {faceId.Value} edge {coedge.EdgeId.Value} planar hyperbola flattening requires the hyperbola plane to match the face plane.", PlanarCurveFlatteningUnsupportedSource)]);
}
if (!body.Bindings.TryGetEdgeBinding(coedge.EdgeId, out var binding) || binding.TrimInterval is not ParameterInterval trim)
{
return KernelResult<IReadOnlyList<Point3D>>.Failure([
CreateInvalidArgument($"Face {faceId.Value} edge {coedge.EdgeId.Value} requires a bounded hyperbola trim.", PlanarCurveFlatteningFailedSource)]);
}
var sampled = SampleHyperbolaCurve(hyperbola, trim, options).ToList();
if (coedge.IsReversed ^ traversalSwapped ^ !binding.OrientedEdgeSense)
{
sampled.Reverse();
}
sampled[0] = start;
sampled[^1] = end;
return KernelResult<IReadOnlyList<Point3D>>.Success(sampled.Skip(1).ToArray());
}
private static IReadOnlyList<Point3D> SampleHyperbolaCurve(Hyperbola3Curve hyperbola, ParameterInterval trim, DisplayTessellationOptions options)
{
// This is a display/M8 carrier only. It adaptively controls the exact
// midpoint-to-chord deviation and tangent turn, while preserving the exact
// bounded support endpoints. The B-rep still owns Hyperbola3Curve.
var points = new List<Point3D> { hyperbola.Evaluate(trim.Start) };
AppendHyperbolaSegment(hyperbola, trim.Start, trim.End, hyperbola.Evaluate(trim.Start), hyperbola.Evaluate(trim.End), options, points, 0);
return points;
}
private static void AppendHyperbolaSegment(Hyperbola3Curve hyperbola, double start, double end, Point3D startPoint, Point3D endPoint, DisplayTessellationOptions options, List<Point3D> points, int depth)
{
var middle = start + ((end - start) * 0.5d);
var middlePoint = hyperbola.Evaluate(middle);
var chord = endPoint - startPoint;
var chordLength = chord.Length;
var midpointDeviation = chordLength <= 1e-14d
? (middlePoint - startPoint).Length
: ((middlePoint - startPoint).Cross(chord).Length / chordLength);
var tangentTurn = double.Acos(System.Math.Clamp(
hyperbola.Tangent(start).ToVector().Dot(hyperbola.Tangent(end).ToVector()), -1d, 1d));
var canSplit = depth < 32 && points.Count < options.MaximumSegments;
if (canSplit && (midpointDeviation > options.ChordTolerance || tangentTurn > options.AngularToleranceRadians))
{
AppendHyperbolaSegment(hyperbola, start, middle, startPoint, middlePoint, options, points, depth + 1);
AppendHyperbolaSegment(hyperbola, middle, end, middlePoint, endPoint, options, points, depth + 1);
return;
}
if ((endPoint - points[^1]).LengthSquared > 1e-24d) points.Add(endPoint);
}
private static int CalculateSegmentCount(double angleSpan, double radius, DisplayTessellationOptions options)
{
var byAngle = (int)double.Ceiling(angleSpan / options.AngularToleranceRadians);
var byChord = 1;
if (radius > 0d)
{
var ratio = 1d - (options.ChordTolerance / radius);
ratio = System.Math.Clamp(ratio, -1d, 1d);
var halfStep = double.Acos(ratio);
if (halfStep > 0d)
{
byChord = (int)double.Ceiling(angleSpan / (2d * halfStep));
}
}
var segments = System.Math.Max(options.MinimumSegments, System.Math.Max(byAngle, byChord));
return System.Math.Clamp(segments, options.MinimumSegments, options.MaximumSegments);
}
private static KernelDiagnostic CreateInvalidArgument(string message, string? source = null)
=> new(KernelDiagnosticCode.InvalidArgument, KernelDiagnosticSeverity.Error, message, source);
private static KernelDiagnostic CreateNotImplemented(string message, string? source = null)
=> new(KernelDiagnosticCode.NotImplemented, KernelDiagnosticSeverity.Error, message, source);
private static KernelDiagnostic CreateValidationError(string message, string source)
=> new(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error, message, source);
private static KernelDiagnostic CreateValidationWarning(string message, string source)
=> new(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Warning, message, source);
}