Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add JudgmentEngine shell for point containment classification

Yuechen Li3f872bbaaefa
diff --git a/Aetheris.Kernel.Core.Tests/Brep/Queries/BrepSpatialQueriesPointClassificationTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Queries/BrepSpatialQueriesPointClassificationTests.cs
index d5ace909..fbf26ac7 100644
--- a/Aetheris.Kernel.Core.Tests/Brep/Queries/BrepSpatialQueriesPointClassificationTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Brep/Queries/BrepSpatialQueriesPointClassificationTests.cs
@@ -43,6 +43,17 @@ public sealed class BrepSpatialQueriesPointClassificationTests
Assert.Equal(PointContainment.Boundary, BrepSpatialQueries.ClassifyPoint(sphere, new Point3D(5d, 0d, 0d)).Value);
}
+ [Fact]
+ public void PrimitiveBody_ClassifyPoint_UsesJudgmentShellAndReportsSelectedCandidate()
+ {
+ var box = BrepPrimitives.CreateBox(2d, 2d, 2d).Value;
+ var result = BrepSpatialQueries.ClassifyPoint(box, Point3D.Origin);
+
+ Assert.True(result.IsSuccess);
+ Assert.Equal(PointContainment.Inside, result.Value);
+ Assert.Contains(result.Diagnostics, d => d.Message.Contains("strategy selected: primitive_analytic", StringComparison.Ordinal));
+ }
+
[Fact]
public void UnsupportedBody_ClassifyPoint_ReturnsUnknownWithDiagnostic()
{
@@ -53,5 +64,6 @@ public sealed class BrepSpatialQueriesPointClassificationTests
Assert.True(result.IsSuccess);
Assert.Equal(PointContainment.Unknown, result.Value);
Assert.Contains(result.Diagnostics, d => d.Message.Contains("supports primitive", StringComparison.Ordinal));
+ Assert.Contains(result.Diagnostics, d => d.Message.Contains("strategy selected: unknown", StringComparison.Ordinal));
}
}
diff --git a/Aetheris.Kernel.Core/Brep/Queries/BrepSpatialQueries.cs b/Aetheris.Kernel.Core/Brep/Queries/BrepSpatialQueries.cs
index 5e54ad86..1e534f77 100644
--- a/Aetheris.Kernel.Core/Brep/Queries/BrepSpatialQueries.cs
+++ b/Aetheris.Kernel.Core/Brep/Queries/BrepSpatialQueries.cs
@@ -1,6 +1,7 @@
using Aetheris.Kernel.Core.Diagnostics;
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Geometry.Surfaces;
+using Aetheris.Kernel.Core.Judgment;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Numerics;
using Aetheris.Kernel.Core.Results;
@@ -14,6 +15,16 @@ namespace Aetheris.Kernel.Core.Brep.Queries;
/// </summary>
public static class BrepSpatialQueries
{
+ private static readonly JudgmentEngine<PointContainmentContext> PointContainmentJudgmentEngine = new();
+ private static readonly IReadOnlyList<JudgmentCandidate<PointContainmentContext>> PointContainmentCandidates =
+ [
+ new("primitive_analytic", static context => context.HasPrimitive, static _ => 100d, static _ => "Body is not recognized as an analytic primitive."),
+ new("boundary_first", static _ => false, static _ => 80d, static context => context.BoundaryFirstUnavailableReason),
+ new("planar_closed_shell", static _ => false, static _ => 70d, static context => context.PlanarClosedShellUnavailableReason),
+ new("multi_axis_ray_consensus", static context => context.GenericRayHitProviderAvailable, static _ => 60d, static context => context.MultiAxisRayConsensusUnavailableReason),
+ new("unknown", static _ => true, static _ => 0d)
+ ];
+
public static KernelResult<IReadOnlyList<RayHit>> Raycast(
BrepBody body,
Ray3D ray,
@@ -51,13 +62,26 @@ public static class BrepSpatialQueries
ToleranceContext? tolerance = null)
{
var context = tolerance ?? ToleranceContext.Default;
-
- if (!TryResolvePrimitive(body, out var primitive, out var diagnostic))
+ var resolvedPrimitive = TryResolvePrimitive(body, out var primitive, out var primitiveDiagnostic);
+ var containmentContext = BuildPointContainmentContext(body, point, context, resolvedPrimitive, primitive, primitiveDiagnostic);
+ var selection = PointContainmentJudgmentEngine.Evaluate(containmentContext, PointContainmentCandidates);
+ if (!selection.IsSuccess)
{
- return KernelResult<PointContainment>.Success(PointContainment.Unknown, [diagnostic with { Severity = KernelDiagnosticSeverity.Warning }]);
+ return KernelResult<PointContainment>.Success(
+ PointContainment.Unknown,
+ [new KernelDiagnostic(KernelDiagnosticCode.NotImplemented, KernelDiagnosticSeverity.Warning, "Point containment has no admissible strategy.", Source: nameof(BrepSpatialQueries))]);
}
- var containment = primitive.Kind switch
+ return selection.Selection!.Value.Candidate.Name switch
+ {
+ "primitive_analytic" => KernelResult<PointContainment>.Success(ClassifyPrimitive(containmentContext.Primitive, point, context), BuildSelectionDiagnostics(selection, containmentContext)),
+ "unknown" => KernelResult<PointContainment>.Success(PointContainment.Unknown, BuildSelectionDiagnostics(selection, containmentContext)),
+ _ => KernelResult<PointContainment>.Success(PointContainment.Unknown, BuildSelectionDiagnostics(selection, containmentContext))
+ };
+ }
+
+ private static PointContainment ClassifyPrimitive(PrimitiveDescriptor primitive, Point3D point, ToleranceContext context) =>
+ primitive.Kind switch
{
PrimitiveKind.Box => ClassifyBoxPoint(primitive, point, context),
PrimitiveKind.Cylinder => ClassifyCylinderPoint(primitive, point, context),
@@ -65,9 +89,59 @@ public static class BrepSpatialQueries
_ => PointContainment.Unknown
};
- return KernelResult<PointContainment>.Success(containment);
+ private static PointContainmentContext BuildPointContainmentContext(
+ BrepBody body,
+ Point3D point,
+ ToleranceContext tolerance,
+ bool resolvedPrimitive,
+ PrimitiveDescriptor primitive,
+ KernelDiagnostic primitiveDiagnostic)
+ {
+ var hasPrimitive = resolvedPrimitive && primitive.Kind is PrimitiveKind.Box or PrimitiveKind.Cylinder or PrimitiveKind.Sphere;
+ return new PointContainmentContext(
+ point,
+ new BoundingBox3D(point, point),
+ tolerance,
+ hasPrimitive,
+ primitive,
+ primitiveDiagnostic with { Severity = KernelDiagnosticSeverity.Warning },
+ GenericRayHitProviderAvailable: false,
+ BoundaryFirstUnavailableReason: "Boundary-first containment is scaffolded but no trusted trimmed-face boundary distance query is available yet.",
+ PlanarClosedShellUnavailableReason: "Planar closed-shell exact containment is scaffolded but not enabled in this milestone.",
+ MultiAxisRayConsensusUnavailableReason: "Deterministic six-axis ray consensus requires a generic ray-hit provider, which is not available yet.");
+ }
+
+ private static IReadOnlyList<KernelDiagnostic> BuildSelectionDiagnostics(JudgmentResult<PointContainmentContext> selection, PointContainmentContext context)
+ {
+ var diagnostics = new List<KernelDiagnostic>();
+ if (!context.HasPrimitive)
+ {
+ diagnostics.Add(context.PrimitiveDiagnostic);
+ }
+
+ if (selection.Selection.HasValue)
+ {
+ var candidate = selection.Selection.Value.Candidate;
+ diagnostics.Add(new KernelDiagnostic(KernelDiagnosticCode.NotImplemented, KernelDiagnosticSeverity.Info, $"Point containment strategy selected: {candidate.Name}.", Source: nameof(BrepSpatialQueries)));
+ }
+
+ diagnostics.AddRange(selection.Rejections.Select(rejection =>
+ new KernelDiagnostic(KernelDiagnosticCode.NotImplemented, KernelDiagnosticSeverity.Info, $"Point containment strategy rejected: {rejection.CandidateName} ({rejection.Reason})", Source: nameof(BrepSpatialQueries))));
+ return diagnostics;
}
+ private sealed record PointContainmentContext(
+ Point3D Point,
+ BoundingBox3D BoundingBox,
+ ToleranceContext Tolerance,
+ bool HasPrimitive,
+ PrimitiveDescriptor Primitive,
+ KernelDiagnostic PrimitiveDiagnostic,
+ bool GenericRayHitProviderAvailable,
+ string BoundaryFirstUnavailableReason,
+ string PlanarClosedShellUnavailableReason,
+ string MultiAxisRayConsensusUnavailableReason);
+
private static IReadOnlyList<RayHit> IntersectBox(PrimitiveDescriptor primitive, Ray3D ray, RayQueryOptions options, ToleranceContext tolerance)
{
var min = primitive.BoxMin;