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.csindex 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 BrepBooleanTestsAssert.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 BrepBooleanTestsAssert.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.csindex 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 BrepBooleanreturn 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 BrepBooleanreturn 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 BrepBooleanreturn 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.csindex 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);