Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Implement bounded orthogonal pocket subtract family

Yuechen Lid357a3bf78e8
diff --git a/Aetheris.Kernel.Core.Tests/Brep/Boolean/BrepBooleanTests.cs b/Aetheris.Kernel.Core.Tests/Brep/Boolean/BrepBooleanTests.cs
index 9056b239..27f70734 100644
--- a/Aetheris.Kernel.Core.Tests/Brep/Boolean/BrepBooleanTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Brep/Boolean/BrepBooleanTests.cs
@@ -232,7 +232,7 @@ public sealed class BrepBooleanTests
Assert.False(result.IsSuccess);
var diagnostic = Assert.Single(result.Diagnostics);
Assert.Equal(KernelDiagnosticCode.NotImplemented, diagnostic.Code);
- Assert.Equal("Boolean Subtract: box subtraction result is not representable as a single box in M13.", diagnostic.Message);
+ Assert.Equal("Boolean Subtract: bounded orthogonal pocket family requires a single pocket mouth; through-slots and multi-face openings remain deferred.", diagnostic.Message);
}
[Fact]
@@ -249,6 +249,50 @@ public sealed class BrepBooleanTests
Assert.True(BrepBindingValidator.Validate(result.Value, true).IsSuccess);
}
+ [Fact]
+ public void Subtract_OpenFaceRectangularPocket_RebuildsBoundedOrthogonalPocket()
+ {
+ var left = BrepBooleanBoxRecognition.CreateBoxFromExtents(new AxisAlignedBoxExtents(0d, 10d, 0d, 8d, 0d, 6d)).Value;
+ var right = BrepBooleanBoxRecognition.CreateBoxFromExtents(new AxisAlignedBoxExtents(2d, 8d, 2d, 6d, 3d, 6d)).Value;
+
+ var result = BrepBoolean.Subtract(left, right);
+
+ Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => d.Message)));
+ Assert.False(BrepBooleanBoxRecognition.TryRecognizeAxisAlignedBox(result.Value, ToleranceContext.Default, out _, out _));
+ Assert.True(BrepBindingValidator.Validate(result.Value, requireAllEdgeAndFaceBindings: true).IsSuccess);
+ Assert.NotNull(result.Value.SafeBooleanComposition);
+ Assert.NotNull(result.Value.SafeBooleanComposition!.OccupiedCells);
+ Assert.NotEmpty(result.Value.SafeBooleanComposition.OccupiedCells!);
+ }
+
+ [Fact]
+ public void Subtract_EnclosedRectangularCavity_RemainsExplicitlyDeferred()
+ {
+ var left = BrepBooleanBoxRecognition.CreateBoxFromExtents(new AxisAlignedBoxExtents(0d, 10d, 0d, 8d, 0d, 6d)).Value;
+ var right = BrepBooleanBoxRecognition.CreateBoxFromExtents(new AxisAlignedBoxExtents(2d, 8d, 2d, 6d, 2d, 5d)).Value;
+
+ var result = BrepBoolean.Subtract(left, right);
+
+ Assert.False(result.IsSuccess);
+ var diagnostic = Assert.Single(result.Diagnostics);
+ Assert.Equal(KernelDiagnosticCode.NotImplemented, diagnostic.Code);
+ Assert.Equal("Boolean Subtract: bounded orthogonal pocket family requires the subtract box to open to exactly one exterior root face; fully enclosed cavities remain deferred.", diagnostic.Message);
+ }
+
+ [Fact]
+ public void Subtract_TangentToolContact_IsRejectedAsDegenerate()
+ {
+ var left = BrepBooleanBoxRecognition.CreateBoxFromExtents(new AxisAlignedBoxExtents(0d, 10d, 0d, 8d, 0d, 6d)).Value;
+ var right = BrepBooleanBoxRecognition.CreateBoxFromExtents(new AxisAlignedBoxExtents(2d, 8d, 2d, 6d, 6d, 9d)).Value;
+
+ var result = BrepBoolean.Subtract(left, right);
+
+ Assert.False(result.IsSuccess);
+ var diagnostic = Assert.Single(result.Diagnostics);
+ Assert.Equal(KernelDiagnosticCode.NotImplemented, diagnostic.Code);
+ Assert.Equal("Boolean Subtract: bounded orthogonal pocket family rejects tangent/zero-thickness subtract contact.", diagnostic.Message);
+ }
+
[Fact]
public void Subtract_BoxCylinderThroughHole_Returns_ManifoldBodyWithCylindricalHole()
diff --git a/Aetheris.Kernel.Core/Brep/Boolean/BrepBoolean.cs b/Aetheris.Kernel.Core/Brep/Boolean/BrepBoolean.cs
index 70b57d6f..be4a9cae 100644
--- a/Aetheris.Kernel.Core/Brep/Boolean/BrepBoolean.cs
+++ b/Aetheris.Kernel.Core/Brep/Boolean/BrepBoolean.cs
@@ -398,6 +398,11 @@ public static class BrepBoolean
return new BooleanClassificationData(intersections, IsComputed: true, FragmentCount: 0, SingleBoxResult: null, SafeCompositionResult: null, UnsupportedReason: unsupportedReason ?? $"Boolean {operation}: box union is outside the bounded connected orthogonal additive family for F1.");
}
+ if (intersections.IsTouchingOnly)
+ {
+ return new BooleanClassificationData(intersections, IsComputed: true, FragmentCount: 0, SingleBoxResult: null, SafeCompositionResult: null, UnsupportedReason: "Boolean Subtract: bounded orthogonal pocket family rejects tangent/zero-thickness subtract contact.");
+ }
+
if (!left.OverlapsWithPositiveVolume(right, tolerance))
{
return new BooleanClassificationData(intersections, IsComputed: true, FragmentCount: 1, SingleBoxResult: left, SafeCompositionResult: null, UnsupportedReason: null);
@@ -413,6 +418,27 @@ public static class BrepBoolean
return new BooleanClassificationData(intersections, IsComputed: true, FragmentCount: 1, SingleBoxResult: singleBox, SafeCompositionResult: null, UnsupportedReason: null);
}
+ if (TryClassifyBoundedOrthogonalPocketSubtract(left, right, tolerance, out var pocketCells, out var pocketUnsupportedReason))
+ {
+ return new BooleanClassificationData(
+ intersections,
+ IsComputed: true,
+ FragmentCount: 1,
+ SingleBoxResult: null,
+ SafeCompositionResult: new SafeBooleanComposition(
+ left,
+ [],
+ SafeBooleanRootDescriptor.FromBox(left),
+ pocketCells),
+ UnsupportedReason: null,
+ OrthogonalUnionCells: pocketCells);
+ }
+
+ if (pocketUnsupportedReason is not null)
+ {
+ return new BooleanClassificationData(intersections, IsComputed: true, FragmentCount: 0, SingleBoxResult: null, SafeCompositionResult: null, UnsupportedReason: pocketUnsupportedReason);
+ }
+
return new BooleanClassificationData(intersections, IsComputed: true, FragmentCount: 0, SingleBoxResult: null, SafeCompositionResult: null, UnsupportedReason: $"Boolean {operation}: box subtraction result is not representable as a single box in M13.");
}
@@ -758,6 +784,136 @@ public static class BrepBoolean
return xFaceTouch || yFaceTouch || zFaceTouch;
}
+ private static bool TryClassifyBoundedOrthogonalPocketSubtract(
+ AxisAlignedBoxExtents left,
+ AxisAlignedBoxExtents right,
+ ToleranceContext tolerance,
+ out IReadOnlyList<AxisAlignedBoxExtents> occupiedCells,
+ out string? unsupportedReason)
+ {
+ occupiedCells = Array.Empty<AxisAlignedBoxExtents>();
+ unsupportedReason = null;
+
+ var overlap = AxisAlignedBoxExtents.Intersection(left, right);
+ if (overlap is null || !overlap.Value.HasPositiveVolume(tolerance))
+ {
+ unsupportedReason = "Boolean Subtract: orthogonal pocket family requires positive-volume overlap between the root and subtract tool.";
+ return false;
+ }
+
+ var removed = overlap.Value;
+ var touchesMinX = ToleranceMath.AlmostEqual(removed.MinX, left.MinX, tolerance);
+ var touchesMaxX = ToleranceMath.AlmostEqual(removed.MaxX, left.MaxX, tolerance);
+ var touchesMinY = ToleranceMath.AlmostEqual(removed.MinY, left.MinY, tolerance);
+ var touchesMaxY = ToleranceMath.AlmostEqual(removed.MaxY, left.MaxY, tolerance);
+ var touchesMinZ = ToleranceMath.AlmostEqual(removed.MinZ, left.MinZ, tolerance);
+ var touchesMaxZ = ToleranceMath.AlmostEqual(removed.MaxZ, left.MaxZ, tolerance);
+ var mouthTouchCount = (touchesMinX ? 1 : 0) + (touchesMaxX ? 1 : 0) + (touchesMinY ? 1 : 0) + (touchesMaxY ? 1 : 0) + (touchesMinZ ? 1 : 0) + (touchesMaxZ ? 1 : 0);
+
+ if (mouthTouchCount == 0)
+ {
+ unsupportedReason = "Boolean Subtract: bounded orthogonal pocket family requires the subtract box to open to exactly one exterior root face; fully enclosed cavities remain deferred.";
+ return false;
+ }
+
+ if (mouthTouchCount > 1)
+ {
+ unsupportedReason = "Boolean Subtract: bounded orthogonal pocket family requires a single pocket mouth; through-slots and multi-face openings remain deferred.";
+ return false;
+ }
+
+ var sideWallPositiveX = removed.MinX - left.MinX;
+ var sideWallNegativeX = left.MaxX - removed.MaxX;
+ var sideWallPositiveY = removed.MinY - left.MinY;
+ var sideWallNegativeY = left.MaxY - removed.MaxY;
+ var sideWallPositiveZ = removed.MinZ - left.MinZ;
+ var sideWallNegativeZ = left.MaxZ - removed.MaxZ;
+
+ if ((touchesMinX || touchesMaxX) && (!HasStrictThickness(sideWallPositiveY)
+ || !HasStrictThickness(sideWallNegativeY)
+ || !HasStrictThickness(sideWallPositiveZ)
+ || !HasStrictThickness(sideWallNegativeZ)))
+ {
+ unsupportedReason = "Boolean Subtract: bounded orthogonal pocket family requires strictly positive wall/floor thickness; tangent or zero-thickness side walls are unsupported.";
+ return false;
+ }
+
+ if ((touchesMinY || touchesMaxY) && (!HasStrictThickness(sideWallPositiveX)
+ || !HasStrictThickness(sideWallNegativeX)
+ || !HasStrictThickness(sideWallPositiveZ)
+ || !HasStrictThickness(sideWallNegativeZ)))
+ {
+ unsupportedReason = "Boolean Subtract: bounded orthogonal pocket family requires strictly positive wall/floor thickness; tangent or zero-thickness side walls are unsupported.";
+ return false;
+ }
+
+ if ((touchesMinZ || touchesMaxZ) && (!HasStrictThickness(sideWallPositiveX)
+ || !HasStrictThickness(sideWallNegativeX)
+ || !HasStrictThickness(sideWallPositiveY)
+ || !HasStrictThickness(sideWallNegativeY)))
+ {
+ unsupportedReason = "Boolean Subtract: bounded orthogonal pocket family requires strictly positive wall/floor thickness; tangent or zero-thickness side walls are unsupported.";
+ return false;
+ }
+
+ var splitX = new[] { left.MinX, removed.MinX, removed.MaxX, left.MaxX }.Distinct().OrderBy(v => v).ToArray();
+ var splitY = new[] { left.MinY, removed.MinY, removed.MaxY, left.MaxY }.Distinct().OrderBy(v => v).ToArray();
+ var splitZ = new[] { left.MinZ, removed.MinZ, removed.MaxZ, left.MaxZ }.Distinct().OrderBy(v => v).ToArray();
+ var cells = new List<AxisAlignedBoxExtents>();
+
+ for (var ix = 0; ix < splitX.Length - 1; ix++)
+ {
+ for (var iy = 0; iy < splitY.Length - 1; iy++)
+ {
+ for (var iz = 0; iz < splitZ.Length - 1; iz++)
+ {
+ var candidate = new AxisAlignedBoxExtents(
+ splitX[ix],
+ splitX[ix + 1],
+ splitY[iy],
+ splitY[iy + 1],
+ splitZ[iz],
+ splitZ[iz + 1]);
+
+ if (!candidate.HasPositiveVolume(tolerance))
+ {
+ continue;
+ }
+
+ if (!left.Contains(candidate, tolerance))
+ {
+ continue;
+ }
+
+ if (removed.Contains(candidate, tolerance))
+ {
+ continue;
+ }
+
+ cells.Add(candidate);
+ }
+ }
+ }
+
+ if (cells.Count == 0)
+ {
+ unsupportedReason = "Boolean Subtract: bounded orthogonal pocket reconstruction produced no occupied cells.";
+ return false;
+ }
+
+ if (!TryValidateOrthogonalCellConnectivity(cells, tolerance))
+ {
+ unsupportedReason = "Boolean Subtract: bounded orthogonal pocket result would be disconnected or only edge-connected.";
+ return false;
+ }
+
+ occupiedCells = cells;
+ return true;
+
+ bool HasStrictThickness(double thickness)
+ => thickness > (2d * tolerance.Linear);
+ }
+
private static bool PositiveOverlap(double minA, double maxA, double minB, double maxB, ToleranceContext tolerance)
=> (System.Math.Min(maxA, maxB) - System.Math.Max(minA, minB)) > tolerance.Linear;
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentBuildAndExportTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentBuildAndExportTests.cs
index b2b1c487..06757c11 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentBuildAndExportTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentBuildAndExportTests.cs
@@ -504,6 +504,18 @@ public sealed class FirmamentBuildAndExportTests
&& diagnostic.Message.Contains("sequential safe composition only supports subtracting supported analytic holes", StringComparison.Ordinal));
}
+ [Fact]
+ public void Run_FrictionLabPocketedPlate_NowFailsWithExplicitEnclosedPocketDiagnostic()
+ {
+ var fullSourcePath = Path.Combine(FirmamentCorpusHarness.RepoRoot(), "Aetheris.Firmament.FrictionLab/Cases/pocketed-plate/part.firmament");
+ var result = FirmamentBuildAndExport.Run(fullSourcePath);
+
+ Assert.False(result.IsSuccess);
+ Assert.Contains(result.Diagnostics, diagnostic =>
+ diagnostic.Source == "BrepBoolean.RebuildResult"
+ && diagnostic.Message.Contains("requires the subtract box to open to exactly one exterior root face", StringComparison.Ordinal));
+ }
+
private static void AssertExampleBuildAndExport(string sourcePath, string expectedFileName, string expectedFeatureId, int expectedOpIndex, string expectedBodyCategory, string expectedFeatureKind)
{
var fullSourcePath = FirmamentCorpusHarness.ResolveFixtureFullPath(sourcePath);