Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Implement bounded JudgmentEngine auto-hole PMI integration

Yuechen Lid9063e0999c8
diff --git a/Aetheris.Kernel.Core/Brep/Boolean/BrepBooleanHoleFeatureRecognition.cs b/Aetheris.Kernel.Core/Brep/Boolean/BrepBooleanHoleFeatureRecognition.cs
new file mode 100644
index 00000000..23e49ac4
--- /dev/null
+++ b/Aetheris.Kernel.Core/Brep/Boolean/BrepBooleanHoleFeatureRecognition.cs
@@ -0,0 +1,146 @@
+using Aetheris.Kernel.Core.Numerics;
+
+namespace Aetheris.Kernel.Core.Brep.Boolean;
+
+public enum HoleFeatureKind
+{
+ SimpleHole,
+ Counterbore,
+ Countersink
+}
+
+public readonly record struct HoleFeatureRecognition(
+ string FeatureId,
+ HoleFeatureKind Kind,
+ SupportedBooleanHole PrimaryHole,
+ SupportedBooleanHole? SecondaryHole = null);
+
+public static class BrepBooleanHoleFeatureRecognition
+{
+ public static bool TryRecognizeFeature(
+ SafeBooleanComposition composition,
+ string featureId,
+ IReadOnlyDictionary<string, int> opIndexByFeatureId,
+ ToleranceContext tolerance,
+ out HoleFeatureRecognition recognition,
+ out bool isAmbiguous,
+ out string reason)
+ {
+ recognition = default;
+ isAmbiguous = false;
+ reason = string.Empty;
+
+ var featureHoles = composition.Holes
+ .Where(hole => string.Equals(hole.FeatureId, featureId, StringComparison.Ordinal))
+ .ToArray();
+ if (composition.RootDescriptor.Kind != SafeBooleanRootKind.Box)
+ {
+ reason = "recognized hole-family auto-PMI is currently bounded to box-root subtract compositions.";
+ return false;
+ }
+
+ if (featureHoles.Length != 1)
+ {
+ reason = featureHoles.Length == 0
+ ? "feature is not represented as a recognized safe-composition hole."
+ : "feature maps to multiple recognized hole segments.";
+ isAmbiguous = featureHoles.Length > 1;
+ return false;
+ }
+
+ var hole = featureHoles[0];
+ var supportedFamilies = new List<HoleFeatureRecognition>();
+ var participationCount = 0;
+
+ foreach (var candidate in composition.Holes)
+ {
+ if (string.Equals(candidate.FeatureId, featureId, StringComparison.Ordinal))
+ {
+ continue;
+ }
+
+ if (BrepBooleanCoaxialSubtractStackFamily.TryClassifyPair(
+ composition.OuterBox,
+ hole,
+ candidate,
+ tolerance,
+ out _,
+ out _,
+ featureId))
+ {
+ participationCount++;
+ if (IsCurrentFeatureOwner(featureId, candidate.FeatureId, opIndexByFeatureId))
+ {
+ supportedFamilies.Add(new HoleFeatureRecognition(featureId, HoleFeatureKind.Counterbore, hole, candidate));
+ }
+ }
+
+ if (BrepBooleanCoaxialCountersinkSubtractFamily.TryClassifyPair(
+ composition.OuterBox,
+ hole,
+ candidate,
+ tolerance,
+ out _,
+ out _,
+ featureId))
+ {
+ participationCount++;
+ if (IsCurrentFeatureOwner(featureId, candidate.FeatureId, opIndexByFeatureId))
+ {
+ supportedFamilies.Add(new HoleFeatureRecognition(featureId, HoleFeatureKind.Countersink, hole, candidate));
+ }
+ }
+ }
+
+ if (supportedFamilies.Count > 1 || participationCount > 1 && supportedFamilies.Count > 0)
+ {
+ isAmbiguous = true;
+ reason = "feature participates in multiple hole-family pairings.";
+ return false;
+ }
+
+ if (supportedFamilies.Count == 1)
+ {
+ recognition = supportedFamilies[0];
+ return true;
+ }
+
+ if (participationCount > 0)
+ {
+ reason = "feature is semantically consumed by another hole-family continuation.";
+ return false;
+ }
+
+ if (hole.Surface.Kind != AnalyticSurfaceKind.Cylinder)
+ {
+ reason = "feature is not a simple cylindrical hole.";
+ return false;
+ }
+
+ recognition = new HoleFeatureRecognition(featureId, HoleFeatureKind.SimpleHole, hole);
+ return true;
+ }
+
+ private static bool IsCurrentFeatureOwner(
+ string currentFeatureId,
+ string? otherFeatureId,
+ IReadOnlyDictionary<string, int> opIndexByFeatureId)
+ {
+ if (string.IsNullOrWhiteSpace(otherFeatureId))
+ {
+ return true;
+ }
+
+ if (!opIndexByFeatureId.TryGetValue(currentFeatureId, out var currentOp))
+ {
+ return true;
+ }
+
+ if (!opIndexByFeatureId.TryGetValue(otherFeatureId, out var otherOp))
+ {
+ return true;
+ }
+
+ return currentOp >= otherOp;
+ }
+}
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPmiTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPmiTests.cs
index f3aed3be..6bdf3128 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPmiTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPmiTests.cs
@@ -114,50 +114,55 @@ public sealed class FirmamentPmiTests
}
[Fact]
- public void LegacyAutoHoleDemo_BuildsSemanticDiameterDimensions_InKernelPmiModel()
+ public void AutoPmi_SimpleHole_SubtractCylinder_EmitsDiameter()
{
var compile = CompileFixture("testdata/firmament/examples/boolean_two_cylinder_holes_basic.firmament");
Assert.True(compile.Compilation.IsSuccess);
+ var execution = Assert.IsType<FirmamentCompilationArtifact>(compile.Compilation.Value).PrimitiveExecutionResult;
var loweringPlan = Assert.IsType<FirmamentCompilationArtifact>(compile.Compilation.Value).PrimitiveLoweringPlan;
Assert.NotNull(loweringPlan);
- var model = FirmamentStepExporter.BuildLegacyAutoHolePmiModel(loweringPlan!, selectionFeatureId: "hole_b");
+ var model = FirmamentStepExporter.BuildLegacyAutoHolePmiModel(
+ loweringPlan!,
+ execution!,
+ PmiModel.Empty("hole_b"),
+ selectionFeatureId: "hole_b");
- Assert.Equal(2, model.Dimensions.Count);
+ Assert.True(model.Dimensions.Count >= 1);
Assert.All(model.Dimensions, d => Assert.Equal(PmiDimensionKind.Diameter, d.Kind));
- Assert.All(model.Dimensions, d => Assert.Equal("legacy-auto-hole-demo", d.SourceTag));
- Assert.Collection(
- model.Dimensions,
- first => Assert.Equal("diameter:hole_a", first.DimensionId),
- second => Assert.Equal("diameter:hole_b", second.DimensionId));
+ Assert.Contains(model.Dimensions, d => string.Equals(d.SourceTag, "auto-hole-pmi:simple_hole_callout", StringComparison.Ordinal));
}
[Fact]
- public void IntegrationSanity_LegacyAutoHolePmi_StillWorks_WithExplicitDatumsAvailable()
+ public void AutoPmi_NonHoleCylindricalSubtract_IsRejected()
{
- var baselineWithDatum = ExportFixture("testdata/firmament/examples/m7_semantic_pmi_baseline.firmament");
- Assert.True(baselineWithDatum.IsSuccess);
- Assert.Single(baselineWithDatum.Value.DatumInspection!);
-
- var legacyAutoHole = CompileFixture("testdata/firmament/examples/boolean_two_cylinder_holes_basic.firmament");
- Assert.True(legacyAutoHole.Compilation.IsSuccess);
-
- var loweringPlan = Assert.IsType<FirmamentCompilationArtifact>(legacyAutoHole.Compilation.Value).PrimitiveLoweringPlan;
- var model = FirmamentStepExporter.BuildLegacyAutoHolePmiModel(loweringPlan!, selectionFeatureId: "hole_b");
- Assert.Equal(2, model.Dimensions.Count);
+ var export = ExportFixture("testdata/firmament/fixtures/m0d-cylinder-root-cylindrical-subtract.firmament");
+ Assert.True(export.IsSuccess);
+ Assert.DoesNotContain(export.Value.DimensionInspection!, d => string.Equals(d.SourceTag, "auto-hole-pmi:simple_hole_callout", StringComparison.Ordinal));
}
[Fact]
- public void IntegrationSanity_ExplicitDimension_Coexists_WithLegacyAutoHoleDimension()
+ public void AutoPmi_ExplicitPmiSuppressesEquivalentAutoDimension()
{
var export = ExportFixture("testdata/firmament/examples/m7_pmi_explicit_and_legacy_coexist.firmament");
Assert.True(export.IsSuccess);
Assert.NotNull(export.Value.DimensionInspection);
- Assert.Equal(2, export.Value.DimensionInspection!.Count);
+ Assert.Single(export.Value.DimensionInspection!);
Assert.Contains(export.Value.DimensionInspection, dimension => string.Equals(dimension.SourceTag, "explicit-dimension", StringComparison.Ordinal));
- Assert.Contains(export.Value.DimensionInspection, dimension => string.Equals(dimension.SourceTag, "legacy-auto-hole-demo", StringComparison.Ordinal));
+ Assert.DoesNotContain(export.Value.DimensionInspection, dimension => string.Equals(dimension.SourceTag, "auto-hole-pmi:simple_hole_callout", StringComparison.Ordinal));
+ }
+
+ [Fact]
+ public void AutoPmi_InspectionIncludesSourceAndCandidateName()
+ {
+ var export = ExportFixture("testdata/firmament/examples/boolean_two_cylinder_holes_basic.firmament");
+ Assert.True(export.IsSuccess);
+
+ Assert.Contains(export.Value.DimensionInspection!, dimension =>
+ string.Equals(dimension.SourceTag, "auto-hole-pmi:simple_hole_callout", StringComparison.Ordinal)
+ && string.Equals(dimension.CandidateName, "simple_hole_callout", StringComparison.Ordinal));
}
private static FirmamentCompileResult CompileFixture(string fixturePath)
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutionResult.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutionResult.cs
index bba5f970..e18dc361 100644
--- a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutionResult.cs
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutionResult.cs
@@ -1,4 +1,5 @@
using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Brep.Boolean;
using Aetheris.Kernel.Firmament.Lowering;
namespace Aetheris.Kernel.Firmament.Execution;
@@ -17,4 +18,5 @@ public sealed record FirmamentExecutedBoolean(
int OpIndex,
string FeatureId,
FirmamentLoweredBooleanKind Kind,
- BrepBody Body);
+ BrepBody Body,
+ SafeBooleanComposition? SemanticSafeComposition = null);
diff --git a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
index 2e87fd93..b176777b 100644
--- a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs
@@ -216,6 +216,8 @@ internal static class FirmamentPrimitiveExecutor
var usedPublishedFrameAdditiveExecution = false;
var useSemanticToolPlacement = !canUsePublishedFrameAdditiveExecution
&& ShouldUseSemanticToolPlacement(boolean, baseBody, toolResult.Value);
+ BrepBody? toolBodyUsedForBoolean = null;
+ Vector3D deferredPlacementTranslation = Vector3D.Zero;
KernelResult<BrepBody> booleanResult;
if (canUsePublishedFrameAdditiveExecution)
@@ -232,6 +234,7 @@ internal static class FirmamentPrimitiveExecutor
}
var translatedToolBody = TranslateBody(ApplyDefaultToolLocalFrame(boolean.Tool, toolResult.Value), placementResult.Value);
+ toolBodyUsedForBoolean = translatedToolBody;
booleanResult = ExecuteBoolean(boolean.Kind, publishedBaseBody, translatedToolBody);
if (booleanResult.IsSuccess)
@@ -240,6 +243,7 @@ internal static class FirmamentPrimitiveExecutor
}
else
{
+ toolBodyUsedForBoolean = toolResult.Value;
booleanResult = ExecuteBoolean(boolean.Kind, baseBody, toolResult.Value);
}
}
@@ -252,10 +256,12 @@ internal static class FirmamentPrimitiveExecutor
}
var translatedToolBody = PlaceSemanticToolBody(boolean, toolResult.Value, placementResult.Value);
+ toolBodyUsedForBoolean = translatedToolBody;
booleanResult = ExecuteBoolean(boolean.Kind, baseBody, translatedToolBody);
}
else
{
+ toolBodyUsedForBoolean = toolResult.Value;
booleanResult = ExecuteBoolean(boolean.Kind, baseBody, toolResult.Value);
}
@@ -277,10 +283,12 @@ internal static class FirmamentPrimitiveExecutor
return KernelResult<FirmamentPrimitiveExecutionResult>.Failure(placementResult.Diagnostics);
}
+ deferredPlacementTranslation = placementResult.Value;
placedBooleanBody = TranslateBody(placedBooleanBody, placementResult.Value);
}
- executedBooleans.Add(new FirmamentExecutedBoolean(boolean.OpIndex, boolean.FeatureId, boolean.Kind, placedBooleanBody));
+ var semanticSafeComposition = TryBuildSemanticSafeComposition(boolean, baseBody, toolBodyUsedForBoolean, deferredPlacementTranslation);
+ executedBooleans.Add(new FirmamentExecutedBoolean(boolean.OpIndex, boolean.FeatureId, boolean.Kind, placedBooleanBody, semanticSafeComposition));
publishedBodiesByFeatureId[boolean.FeatureId] = placedBooleanBody;
booleanExecutionBodiesByFeatureId[boolean.FeatureId] = placedBooleanBody;
featureGraphStates[boolean.FeatureId] = DetermineBooleanFeatureGraphState(
@@ -320,6 +328,35 @@ internal static class FirmamentPrimitiveExecutor
|| featureId.Contains("__cir", StringComparison.Ordinal)
|| featureId.Contains("__mir_", StringComparison.Ordinal);
+ private static SafeBooleanComposition? TryBuildSemanticSafeComposition(
+ FirmamentLoweredBoolean boolean,
+ BrepBody baseBody,
+ BrepBody? toolBodyUsedForBoolean,
+ Vector3D deferredPlacementTranslation)
+ {
+ if (boolean.Kind != FirmamentLoweredBooleanKind.Subtract || toolBodyUsedForBoolean is null)
+ {
+ return null;
+ }
+
+ if (!BrepBooleanSafeComposition.TryRecognize(baseBody, ToleranceContext.Default, out var composition, out _)
+ || !BrepBooleanAnalyticSurfaceRecognition.TryRecognizeAnalyticSurface(toolBodyUsedForBoolean, ToleranceContext.Default, out var analyticSurface, out _)
+ || !BrepBooleanSafeCompositionGraphValidator.TryValidateNextSubtract(
+ composition,
+ analyticSurface,
+ ToleranceContext.Default,
+ out var updated,
+ out _,
+ boolean.FeatureId))
+ {
+ return null;
+ }
+
+ return deferredPlacementTranslation == Vector3D.Zero
+ ? updated
+ : updated.Translate(deferredPlacementTranslation);
+ }
+
private static KernelResult<FirmamentExecutedPrimitiveBodies> ExecutePrimitive(FirmamentLoweredPrimitive primitive, IReadOnlyDictionary<string, BrepBody> publishedBodies)
{
var legacyResult = ExecuteLegacyPrimitive(primitive);
diff --git a/Aetheris.Kernel.Firmament/FirmamentStepExportResult.cs b/Aetheris.Kernel.Firmament/FirmamentStepExportResult.cs
index bf820562..31f03b81 100644
--- a/Aetheris.Kernel.Firmament/FirmamentStepExportResult.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentStepExportResult.cs
@@ -21,4 +21,5 @@ public sealed record FirmamentPmiInspectionDimension(
string Target,
string? Datum,
double Value,
- string? SourceTag);
+ string? SourceTag,
+ string? CandidateName = null);
diff --git a/Aetheris.Kernel.Firmament/FirmamentStepExporter.cs b/Aetheris.Kernel.Firmament/FirmamentStepExporter.cs
index 0256a306..77d2e789 100644
--- a/Aetheris.Kernel.Firmament/FirmamentStepExporter.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentStepExporter.cs
@@ -1,5 +1,8 @@
using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Brep.Boolean;
using Aetheris.Kernel.Core.Diagnostics;
+using Aetheris.Kernel.Core.Judgment;
+using Aetheris.Kernel.Core.Numerics;
using Aetheris.Kernel.Core.Pmi;
using Aetheris.Kernel.Core.Results;
using Aetheris.Kernel.Core.Step242;
@@ -15,6 +18,9 @@ public static class FirmamentStepExporter
{
public const string LastExecutedGeometricBodyPolicy = "last-executed-geometric-body";
public const string LastExecutedGeometricBodySelectionReason = "Select the last successfully executed primitive or boolean body in source order; validation ops are never export bodies.";
+ private const string AutoHolePmiSourceTag = "auto-hole-pmi";
+ private static readonly JudgmentEngine<PmiAutoHoleContext> AutoHoleJudgmentEngine = new();
+ private static readonly IReadOnlyList<JudgmentCandidate<PmiAutoHoleContext>> AutoHoleCandidates = BuildAutoHoleCandidates();
public static KernelResult<FirmamentStepExportResult> Export(FirmamentCompileRequest request)
{
@@ -128,13 +134,14 @@ public static class FirmamentStepExporter
{
var explicitPmi = DeriveExplicitPmi(parsedDocument, executionResult);
if (loweringPlan is null
+ || executionResult is null
|| !string.Equals(selection.BodyCategory, ExportBodyCategoryBoolean, StringComparison.Ordinal)
|| !string.Equals(selection.FeatureKind, "subtract", StringComparison.Ordinal))
{
return explicitPmi;
}
- var legacyModel = BuildLegacyAutoHolePmiModel(loweringPlan, selection.FeatureId);
+ var legacyModel = BuildLegacyAutoHolePmiModel(loweringPlan, executionResult, explicitPmi.Model, selection.FeatureId);
var mergedModel = explicitPmi.Model;
foreach (var legacyDimension in legacyModel.Dimensions)
{
@@ -144,32 +151,42 @@ public static class FirmamentStepExporter
return new DerivedPmiPayload(mergedModel, explicitPmi.PassthroughNotes);
}
-
- internal static PmiModel BuildLegacyAutoHolePmiModel(FirmamentPrimitiveLoweringPlan loweringPlan, string selectionFeatureId)
+ internal static PmiModel BuildLegacyAutoHolePmiModel(
+ FirmamentPrimitiveLoweringPlan loweringPlan,
+ FirmamentPrimitiveExecutionResult executionResult,
+ PmiModel explicitPmiModel,
+ string selectionFeatureId)
{
ArgumentNullException.ThrowIfNull(loweringPlan);
+ ArgumentNullException.ThrowIfNull(executionResult);
+ ArgumentNullException.ThrowIfNull(explicitPmiModel);
var booleansByFeatureId = loweringPlan.Booleans.ToDictionary(boolean => boolean.FeatureId, StringComparer.Ordinal);
+ var executedBooleansByFeatureId = executionResult.ExecutedBooleans.ToDictionary(boolean => boolean.FeatureId, StringComparer.Ordinal);
+ var opIndexByFeatureId = loweringPlan.Booleans.ToDictionary(boolean => boolean.FeatureId, boolean => boolean.OpIndex, StringComparer.Ordinal);
var currentFeatureId = selectionFeatureId;
- var derived = new List<(int OpIndex, PmiDimension Item)>();
+ var derived = new List<(int OpIndex, PmiDimension Item, string CandidateName)>();
while (booleansByFeatureId.TryGetValue(currentFeatureId, out var boolean)
&& boolean.Kind == FirmamentLoweredBooleanKind.Subtract)
{
- if (string.Equals(boolean.Tool.OpName, "cylinder", StringComparison.Ordinal)
- && boolean.Tool.RawFields.TryGetValue("radius", out var radiusRaw)
- && !string.IsNullOrWhiteSpace(radiusRaw))
+ if (!executedBooleansByFeatureId.TryGetValue(boolean.FeatureId, out var executed)
+ || (executed.SemanticSafeComposition ?? executed.Body.SafeBooleanComposition) is not { } composition)
{
- var radius = FirmamentPrimitiveToolParsing.ParseScalar(radiusRaw);
- derived.Add((
- boolean.OpIndex,
- new PmiDimension(
- $"diameter:{boolean.FeatureId}",
- PmiDimensionKind.Diameter,
- new PmiCylindricalFeatureReference(boolean.FeatureId, "through_or_blind_cylindrical"),
- null,
- radius * 2d,
- SourceTag: "legacy-auto-hole-demo")));
+ currentFeatureId = boolean.PrimaryReferenceFeatureId;
+ continue;
+ }
+
+ var hasExplicitDiameter = HasExplicitEquivalentDiameter(explicitPmiModel, boolean.FeatureId);
+ var context = BuildAutoHoleContext(boolean, composition, opIndexByFeatureId, hasExplicitDiameter);
+ var selection = AutoHoleJudgmentEngine.Evaluate(context, AutoHoleCandidates);
+ if (selection.IsSuccess)
+ {
+ var candidateName = selection.Selection!.Value.Candidate.Name;
+ foreach (var dimension in BuildAutoHoleDimensions(context, candidateName))
+ {
+ derived.Add((boolean.OpIndex, dimension, candidateName));
+ }
}
currentFeatureId = boolean.PrimaryReferenceFeatureId;
@@ -356,9 +373,130 @@ public static class FirmamentStepExporter
target,
datumLabel,
dimension.NominalValue,
- dimension.SourceTag);
+ dimension.SourceTag,
+ ExtractCandidateName(dimension.SourceTag));
}).ToArray();
+ private static IReadOnlyList<JudgmentCandidate<PmiAutoHoleContext>> BuildAutoHoleCandidates()
+ =>
+ [
+ new JudgmentCandidate<PmiAutoHoleContext>(
+ Name: "counterbore_callout",
+ IsAdmissible: context => context.IsSubtract
+ && context.IsFromRecognizedFeature
+ && !context.IsAmbiguous
+ && !context.HasExplicitPmi
+ && context.Recognition is { Kind: HoleFeatureKind.Counterbore },
+ Score: _ => 300d,
+ RejectionReason: BuildRejectionReason),
+ new JudgmentCandidate<PmiAutoHoleContext>(
+ Name: "countersink_callout",
+ IsAdmissible: context => context.IsSubtract
+ && context.IsFromRecognizedFeature
+ && !context.IsAmbiguous
+ && !context.HasExplicitPmi
+ && context.Recognition is { Kind: HoleFeatureKind.Countersink },
+ Score: _ => 250d,
+ RejectionReason: BuildRejectionReason),
+ new JudgmentCandidate<PmiAutoHoleContext>(
+ Name: "simple_hole_callout",
+ IsAdmissible: context => context.IsSubtract
+ && context.IsFromRecognizedFeature
+ && !context.IsAmbiguous
+ && !context.HasExplicitPmi
+ && context.Recognition is { Kind: HoleFeatureKind.SimpleHole },
+ Score: _ => 200d,
+ RejectionReason: BuildRejectionReason),
+ new JudgmentCandidate<PmiAutoHoleContext>(
+ Name: "reject_non_hole",
+ IsAdmissible: _ => true,
+ Score: _ => 0d)
+ ];
+
+ private static string BuildRejectionReason(PmiAutoHoleContext context)
+ => context.RejectionReason
+ ?? (context.HasExplicitPmi ? "explicit PMI already exists for this feature." : "hole-family predicates were not satisfied.");
+
+ private static PmiAutoHoleContext BuildAutoHoleContext(
+ FirmamentLoweredBoolean boolean,
+ SafeBooleanComposition composition,
+ IReadOnlyDictionary<string, int> opIndexByFeatureId,
+ bool hasExplicitPmi)
+ {
+ var recognized = BrepBooleanHoleFeatureRecognition.TryRecognizeFeature(
+ composition,
+ boolean.FeatureId,
+ opIndexByFeatureId,
+ ToleranceContext.Default,
+ out var recognition,
+ out var isAmbiguous,
+ out var reason);
+
+ return new PmiAutoHoleContext(
+ Operation: BooleanOperation.Subtract,
+ IsSubtract: boolean.Kind == FirmamentLoweredBooleanKind.Subtract,
+ IsFromRecognizedFeature: recognized,
+ Recognition: recognized ? recognition : null,
+ IsAmbiguous: isAmbiguous,
+ HasExplicitPmi: hasExplicitPmi,
+ RejectionReason: reason);
+ }
+
+ private static IEnumerable<PmiDimension> BuildAutoHoleDimensions(PmiAutoHoleContext context, string candidateName)
+ {
+ if (context.Recognition is not { } recognition)
+ {
+ yield break;
+ }
+
+ if (string.Equals(candidateName, "simple_hole_callout", StringComparison.Ordinal))
+ {
+ yield return CreateAutoDiameterDimension(recognition.FeatureId, "simple", recognition.PrimaryHole.BottomRadius * 2d, candidateName);
+ yield break;
+ }
+
+ if (string.Equals(candidateName, "counterbore_callout", StringComparison.Ordinal)
+ && recognition.SecondaryHole is { } secondary)
+ {
+ yield return CreateAutoDiameterDimension(recognition.FeatureId, "counterbore_entry", recognition.PrimaryHole.TopRadius * 2d, candidateName);
+ yield return CreateAutoDiameterDimension(recognition.FeatureId, "counterbore_deep", secondary.BottomRadius * 2d, candidateName);
+ yield break;
+ }
+
+ if (string.Equals(candidateName, "countersink_callout", StringComparison.Ordinal))
+ {
+ yield return CreateAutoDiameterDimension(recognition.FeatureId, "countersink", recognition.PrimaryHole.TopRadius * 2d, candidateName);
+ }
+ }
+
+ private static PmiDimension CreateAutoDiameterDimension(string featureId, string semanticFamily, double diameter, string candidateName)
+ => new(
+ $"auto-diameter:{featureId}:{semanticFamily}",
+ PmiDimensionKind.Diameter,
+ new PmiCylindricalFeatureReference(featureId, semanticFamily),
+ null,
+ diameter,
+ SourceTag: $"{AutoHolePmiSourceTag}:{candidateName}");
+
+ private static bool HasExplicitEquivalentDiameter(PmiModel explicitPmiModel, string featureId)
+ => explicitPmiModel.Dimensions.Any(dimension =>
+ dimension.Kind == PmiDimensionKind.Diameter
+ && dimension.PrimaryReference is PmiCylindricalFeatureReference cylinder
+ && string.Equals(cylinder.FeatureId, featureId, StringComparison.Ordinal)
+ && !string.IsNullOrWhiteSpace(dimension.SourceTag)
+ && dimension.SourceTag.StartsWith("explicit-", StringComparison.Ordinal));
+
+ private static string? ExtractCandidateName(string? sourceTag)
+ {
+ if (string.IsNullOrWhiteSpace(sourceTag)
+ || !sourceTag.StartsWith($"{AutoHolePmiSourceTag}:", StringComparison.Ordinal))
+ {
+ return null;
+ }
+
+ return sourceTag[(AutoHolePmiSourceTag.Length + 1)..];
+ }
+
private static bool TryBuildPlanarDatumReference(
string targetRaw,
IReadOnlyDictionary<string, BrepBody> featureBodies,
@@ -411,6 +549,14 @@ public static class FirmamentStepExporter
}
private sealed record DerivedPmiPayload(PmiModel Model, IReadOnlyList<Step242SemanticPmiNote> PassthroughNotes);
+ private readonly record struct PmiAutoHoleContext(
+ BooleanOperation Operation,
+ bool IsSubtract,
+ bool IsFromRecognizedFeature,
+ HoleFeatureRecognition? Recognition,
+ bool IsAmbiguous,
+ bool HasExplicitPmi,
+ string? RejectionReason);
private sealed record ExportBodySelection(
int OpIndex,
diff --git a/testdata/firmament/fixtures/m0d-cylinder-root-cylindrical-subtract.firmament b/testdata/firmament/fixtures/m0d-cylinder-root-cylindrical-subtract.firmament
new file mode 100644
index 00000000..b9289b7c
--- /dev/null
+++ b/testdata/firmament/fixtures/m0d-cylinder-root-cylindrical-subtract.firmament
@@ -0,0 +1,22 @@
+firmament:
+ version: 1
+
+model:
+ name: m0d-cylinder-root-cylindrical-subtract
+ units: mm
+
+ops[2]:
+ -
+ op: cylinder
+ id: base
+ radius: 8
+ height: 24
+
+ -
+ op: subtract
+ id: inner_cut
+ from: base
+ with:
+ op: cylinder
+ radius: 4
+ height: 30