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.csnew file mode 100644index 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.csindex 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.csindex 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.csindex 2e87fd93..b176777b 100644--- a/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs+++ b/Aetheris.Kernel.Firmament/Execution/FirmamentPrimitiveExecutor.cs@@ -216,6 +216,8 @@ internal static class FirmamentPrimitiveExecutorvar 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 FirmamentPrimitiveExecutorreturn 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.csindex 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.csindex 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 FirmamentStepExporterreturn 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 FirmamentStepExportertarget,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.firmamentnew file mode 100644index 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