Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Implement PMI-M0c explicit semantic dimensions

Yuechen Li52c8be928a9b
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentPmiTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentPmiTests.cs
index d6255160..f3aed3be 100644
--- a/Aetheris.Kernel.Firmament.Tests/FirmamentPmiTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentPmiTests.cs
@@ -72,6 +72,46 @@ public sealed class FirmamentPmiTests
Assert.Equal("base.top_face", datum.Target);
}
+ [Fact]
+ public void ExplicitDiameterAndLinearDistanceToDatum_AreAuthoredAndInspectable()
+ {
+ var compile = CompileFixture("testdata/firmament/examples/m7_pmi_explicit_dimensions.firmament");
+ Assert.True(compile.Compilation.IsSuccess);
+
+ var export = ExportFixture("testdata/firmament/examples/m7_pmi_explicit_dimensions.firmament");
+ Assert.True(export.IsSuccess);
+
+ Assert.NotNull(export.Value.DimensionInspection);
+ Assert.Contains(export.Value.DimensionInspection!, dimension =>
+ string.Equals(dimension.Kind, nameof(PmiDimensionKind.Diameter), StringComparison.Ordinal)
+ && string.Equals(dimension.Target, "main_hole", StringComparison.Ordinal)
+ && Math.Abs(dimension.Value - 10d) < 1e-9d);
+ Assert.Contains(export.Value.DimensionInspection!, dimension =>
+ string.Equals(dimension.Kind, nameof(PmiDimensionKind.LinearDistanceToDatum), StringComparison.Ordinal)
+ && string.Equals(dimension.Target, "main_hole", StringComparison.Ordinal)
+ && string.Equals(dimension.Datum, "A", StringComparison.Ordinal)
+ && Math.Abs(dimension.Value - 12d) < 1e-9d);
+ }
+
+ [Fact]
+ public void Compile_PmiDimension_LinearDistanceToDatum_MissingDatum_IsRejected()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7e-invalid-pmi-dimension-missing-datum.firmament");
+ Assert.False(result.Compilation.IsSuccess);
+
+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);
+ Assert.Contains("references missing datum label 'Z'", diagnostic.Message, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void Compile_PmiDimension_Diameter_OnNonCylindricalTarget_IsRejected()
+ {
+ var result = CompileFixture("testdata/firmament/fixtures/m7e-invalid-pmi-dimension-invalid-target.firmament");
+ Assert.False(result.Compilation.IsSuccess);
+
+ var diagnostic = Assert.Single(result.Compilation.Diagnostics);
+ Assert.Contains("dimension_kind 'diameter' target 'base' to be a cylindrical primitive/feature", diagnostic.Message, StringComparison.Ordinal);
+ }
[Fact]
public void LegacyAutoHoleDemo_BuildsSemanticDiameterDimensions_InKernelPmiModel()
@@ -108,6 +148,18 @@ public sealed class FirmamentPmiTests
Assert.Equal(2, model.Dimensions.Count);
}
+ [Fact]
+ public void IntegrationSanity_ExplicitDimension_Coexists_WithLegacyAutoHoleDimension()
+ {
+ 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.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));
+ }
+
private static FirmamentCompileResult CompileFixture(string fixturePath)
{
var sourceText = FirmamentCorpusHarness.ReadFixtureText(fixturePath);
diff --git a/Aetheris.Kernel.Firmament/FirmamentStepExportResult.cs b/Aetheris.Kernel.Firmament/FirmamentStepExportResult.cs
index 00aa281b..bf820562 100644
--- a/Aetheris.Kernel.Firmament/FirmamentStepExportResult.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentStepExportResult.cs
@@ -8,9 +8,17 @@ public sealed record FirmamentStepExportResult(
string? ExportedFeatureKind = null,
string ExportBodyPolicy = FirmamentStepExporter.LastExecutedGeometricBodyPolicy,
string ExportBodySelectionReason = FirmamentStepExporter.LastExecutedGeometricBodySelectionReason,
- IReadOnlyList<FirmamentPmiInspectionDatum>? DatumInspection = null);
+ IReadOnlyList<FirmamentPmiInspectionDatum>? DatumInspection = null,
+ IReadOnlyList<FirmamentPmiInspectionDimension>? DimensionInspection = null);
public sealed record FirmamentPmiInspectionDatum(
string Label,
string DatumType,
string Target);
+
+public sealed record FirmamentPmiInspectionDimension(
+ string Kind,
+ string Target,
+ string? Datum,
+ double Value,
+ string? SourceTag);
diff --git a/Aetheris.Kernel.Firmament/FirmamentStepExporter.cs b/Aetheris.Kernel.Firmament/FirmamentStepExporter.cs
index 4cf7c1b7..0256a306 100644
--- a/Aetheris.Kernel.Firmament/FirmamentStepExporter.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentStepExporter.cs
@@ -55,7 +55,8 @@ public static class FirmamentStepExporter
selectionResult.Value.OpIndex,
selectionResult.Value.BodyCategory,
selectionResult.Value.FeatureKind,
- DatumInspection: BuildDatumInspection(pmiModel.Model)));
+ DatumInspection: BuildDatumInspection(pmiModel.Model),
+ DimensionInspection: BuildDimensionInspection(pmiModel.Model)));
}
private static KernelResult<ExportBodySelection> SelectExportBody(FirmamentPrimitiveExecutionResult? primitiveExecutionResult)
@@ -126,23 +127,21 @@ public static class FirmamentStepExporter
ExportBodySelection selection)
{
var explicitPmi = DeriveExplicitPmi(parsedDocument, executionResult);
- if (explicitPmi.Model.DatumFeatures.Count > 0
- || explicitPmi.Model.Dimensions.Count > 0
- || explicitPmi.PassthroughNotes.Count > 0)
- {
- return explicitPmi;
- }
-
if (loweringPlan is null
|| !string.Equals(selection.BodyCategory, ExportBodyCategoryBoolean, StringComparison.Ordinal)
|| !string.Equals(selection.FeatureKind, "subtract", StringComparison.Ordinal))
{
- return new DerivedPmiPayload(PmiModel.Empty(selection.FeatureId), []);
+ return explicitPmi;
}
- var model = BuildLegacyAutoHolePmiModel(loweringPlan, selection.FeatureId);
+ var legacyModel = BuildLegacyAutoHolePmiModel(loweringPlan, selection.FeatureId);
+ var mergedModel = explicitPmi.Model;
+ foreach (var legacyDimension in legacyModel.Dimensions)
+ {
+ mergedModel = mergedModel.AddDimension(legacyDimension);
+ }
- return new DerivedPmiPayload(model, []);
+ return new DerivedPmiPayload(mergedModel, explicitPmi.PassthroughNotes);
}
@@ -201,8 +200,9 @@ public static class FirmamentStepExporter
var model = PmiModel.Empty(bodyFeatureId);
var passthroughNotes = new List<Step242SemanticPmiNote>();
- foreach (var entry in parsedDocument.Pmi.Entries)
+ for (var index = 0; index < parsedDocument.Pmi.Entries.Count; index++)
{
+ var entry = parsedDocument.Pmi.Entries[index];
if (!entry.RawFields.TryGetValue("target", out var targetRaw))
{
continue;
@@ -226,7 +226,7 @@ public static class FirmamentStepExporter
}
model = model.AddDimension(new PmiDimension(
- $"diameter:{featureId}",
+ $"explicit-diameter:{featureId}:{index}",
PmiDimensionKind.Diameter,
new PmiCylindricalFeatureReference(featureId, entry.RawFields.TryGetValue("hole_family", out var familyRaw) ? familyRaw : null),
null,
@@ -268,6 +268,43 @@ public static class FirmamentStepExporter
passthroughNotes.Add(new Step242SemanticPmiNote(featureId, targetRaw, text));
}
+ break;
+ case FirmamentParsedPmiKind.Dimension:
+ if (!entry.RawFields.TryGetValue("dimension_kind", out var dimensionKindRaw)
+ || !entry.RawFields.TryGetValue("value", out var valueRaw)
+ || !double.TryParse(valueRaw, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var value))
+ {
+ break;
+ }
+
+ if (string.Equals(dimensionKindRaw, "diameter", StringComparison.Ordinal))
+ {
+ model = model.AddDimension(new PmiDimension(
+ $"explicit-diameter:{featureId}:{index}",
+ PmiDimensionKind.Diameter,
+ new PmiCylindricalFeatureReference(featureId, "through_or_blind_cylindrical"),
+ null,
+ value,
+ SourceTag: "explicit-dimension"));
+ }
+ else if (string.Equals(dimensionKindRaw, "linear_distance_to_datum", StringComparison.Ordinal)
+ && entry.RawFields.TryGetValue("datum", out var datumLabel))
+ {
+ var datum = model.DatumFeatures.FirstOrDefault(existing => string.Equals(existing.Label, datumLabel, StringComparison.OrdinalIgnoreCase));
+ if (datum is null || datum.Kind != PmiDatumFeatureKind.Planar)
+ {
+ break;
+ }
+
+ model = model.AddDimension(new PmiDimension(
+ $"explicit-linear-distance:{featureId}-to-{datum.Label}:{index}",
+ PmiDimensionKind.LinearDistanceToDatum,
+ new PmiCylindricalFeatureReference(featureId, "through_or_blind_cylindrical"),
+ new PmiDatumReference(datum.DatumId),
+ value,
+ SourceTag: "explicit-dimension"));
+ }
+
break;
}
}
@@ -298,6 +335,30 @@ public static class FirmamentStepExporter
: new FirmamentPmiInspectionDatum(datum.Label, datum.Kind.ToString().ToLowerInvariant(), datum.Target.ToString() ?? "unknown"))
.ToArray();
+ private static IReadOnlyList<FirmamentPmiInspectionDimension> BuildDimensionInspection(PmiModel model)
+ => model.Dimensions.Select(dimension =>
+ {
+ var target = dimension.PrimaryReference switch
+ {
+ PmiCylindricalFeatureReference cylindrical => cylindrical.FeatureId,
+ PmiPlanarFaceReference planar => planar.Selector,
+ PmiDatumReference datum => datum.DatumId,
+ _ => dimension.PrimaryReference.ToString() ?? "unknown"
+ };
+
+ var datumLabel = dimension.SecondaryReference is PmiDatumReference datumReference
+ ? model.DatumFeatures.FirstOrDefault(existing => string.Equals(existing.DatumId, datumReference.DatumId, StringComparison.Ordinal))?.Label
+ ?? datumReference.DatumId
+ : null;
+
+ return new FirmamentPmiInspectionDimension(
+ dimension.Kind.ToString(),
+ target,
+ datumLabel,
+ dimension.NominalValue,
+ dimension.SourceTag);
+ }).ToArray();
+
private static bool TryBuildPlanarDatumReference(
string targetRaw,
IReadOnlyDictionary<string, BrepBody> featureBodies,
diff --git a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedPmi.cs b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedPmi.cs
index 0b58017e..a8ec02f8 100644
--- a/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedPmi.cs
+++ b/Aetheris.Kernel.Firmament/ParsedModel/FirmamentParsedPmi.cs
@@ -14,5 +14,6 @@ public enum FirmamentParsedPmiKind
Unknown = 0,
Hole = 1,
Datum = 2,
- Note = 3
+ Note = 3,
+ Dimension = 4
}
diff --git a/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs b/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs
index e07276e0..45419a2a 100644
--- a/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs
+++ b/Aetheris.Kernel.Firmament/Parsing/FirmamentTopLevelParser.cs
@@ -828,6 +828,7 @@ internal static class FirmamentTopLevelParser
"hole" => FirmamentParsedPmiKind.Hole,
"datum" => FirmamentParsedPmiKind.Datum,
"note" => FirmamentParsedPmiKind.Note,
+ "dimension" => FirmamentParsedPmiKind.Dimension,
_ => FirmamentParsedPmiKind.Unknown
};
diff --git a/Aetheris.Kernel.Firmament/Validation/FirmamentPmiValidator.cs b/Aetheris.Kernel.Firmament/Validation/FirmamentPmiValidator.cs
index 6337b92d..2a23f140 100644
--- a/Aetheris.Kernel.Firmament/Validation/FirmamentPmiValidator.cs
+++ b/Aetheris.Kernel.Firmament/Validation/FirmamentPmiValidator.cs
@@ -21,6 +21,7 @@ internal static class FirmamentPmiValidator
.Where(entry => entry.RawFields.TryGetValue("id", out _))
.ToDictionary(entry => entry.RawFields["id"], StringComparer.Ordinal);
var seenDatumLabels = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+ var declaredDatumKindsByLabel = BuildDeclaredDatumKindsByLabel(parsedDocument.Pmi.Entries);
for (var index = 0; index < parsedDocument.Pmi.Entries.Count; index++)
{
@@ -30,7 +31,8 @@ internal static class FirmamentPmiValidator
FirmamentParsedPmiKind.Hole => ValidateHole(entry, index, opsByFeatureId),
FirmamentParsedPmiKind.Datum => ValidateDatum(entry, index, opsByFeatureId, seenDatumLabels),
FirmamentParsedPmiKind.Note => ValidateNote(entry, index, opsByFeatureId),
- _ => Fail($"PMI entry at index {index} has unsupported kind '{entry.KindRaw}'. Supported kinds: hole, datum, note.")
+ FirmamentParsedPmiKind.Dimension => ValidateDimension(entry, index, opsByFeatureId, declaredDatumKindsByLabel),
+ _ => Fail($"PMI entry at index {index} has unsupported kind '{entry.KindRaw}'. Supported kinds: hole, datum, note, dimension.")
};
if (!result.IsSuccess)
@@ -173,6 +175,73 @@ internal static class FirmamentPmiValidator
return KernelResult<bool>.Success(true);
}
+ private static KernelResult<bool> ValidateDimension(
+ FirmamentParsedPmiEntry entry,
+ int index,
+ IReadOnlyDictionary<string, FirmamentParsedOpEntry> opsByFeatureId,
+ IReadOnlyDictionary<string, string> declaredDatumKindsByLabel)
+ {
+ if (!entry.RawFields.TryGetValue("dimension_kind", out var dimensionKind)
+ || string.IsNullOrWhiteSpace(dimensionKind))
+ {
+ return Fail($"PMI dimension entry at index {index} is missing required field 'dimension_kind' (supported: diameter, linear_distance_to_datum).");
+ }
+
+ if (!entry.RawFields.TryGetValue("value", out var valueRaw)
+ || !double.TryParse(valueRaw, NumberStyles.Float, CultureInfo.InvariantCulture, out var nominalValue)
+ || nominalValue <= 0d)
+ {
+ return Fail($"PMI dimension entry at index {index} must declare positive numeric 'value'.");
+ }
+
+ var targetResult = RequireTarget(entry, index, allowSelectorShaped: false, opsByFeatureId);
+ if (!targetResult.IsSuccess)
+ {
+ return KernelResult<bool>.Failure(targetResult.Diagnostics);
+ }
+
+ var targetFeature = targetResult.Value;
+ var normalizedDimensionKind = dimensionKind.Trim();
+
+ if (string.Equals(normalizedDimensionKind, "diameter", StringComparison.Ordinal))
+ {
+ if (!IsSupportedCylindricalDimensionTarget(targetFeature, opsByFeatureId))
+ {
+ return Fail($"PMI dimension entry at index {index} requires dimension_kind 'diameter' target '{targetFeature}' to be a cylindrical primitive/feature.");
+ }
+
+ return KernelResult<bool>.Success(true);
+ }
+
+ if (string.Equals(normalizedDimensionKind, "linear_distance_to_datum", StringComparison.Ordinal))
+ {
+ if (!IsSupportedCylindricalDimensionTarget(targetFeature, opsByFeatureId))
+ {
+ return Fail($"PMI dimension entry at index {index} requires dimension_kind 'linear_distance_to_datum' target '{targetFeature}' to be a cylindrical primitive/feature.");
+ }
+
+ if (!entry.RawFields.TryGetValue("datum", out var datumLabel)
+ || string.IsNullOrWhiteSpace(datumLabel))
+ {
+ return Fail($"PMI dimension entry at index {index} with dimension_kind 'linear_distance_to_datum' is missing required field 'datum'.");
+ }
+
+ if (!declaredDatumKindsByLabel.TryGetValue(datumLabel, out var declaredDatumKind))
+ {
+ return Fail($"PMI dimension entry at index {index} references missing datum label '{datumLabel}'.");
+ }
+
+ if (!string.Equals(declaredDatumKind, "plane", StringComparison.Ordinal))
+ {
+ return Fail($"PMI dimension entry at index {index} requires datum '{datumLabel}' to be planar for dimension_kind 'linear_distance_to_datum'.");
+ }
+
+ return KernelResult<bool>.Success(true);
+ }
+
+ return Fail($"PMI dimension entry at index {index} has unsupported dimension_kind '{dimensionKind}'. Supported: diameter, linear_distance_to_datum.");
+ }
+
private static KernelResult<string> RequireTarget(FirmamentParsedPmiEntry entry, int index, bool allowSelectorShaped, IReadOnlyDictionary<string, FirmamentParsedOpEntry> opsByFeatureId)
{
if (!entry.RawFields.TryGetValue("target", out var targetRaw)
@@ -269,4 +338,35 @@ internal static class FirmamentPmiValidator
|| string.Equals(port, "bottom_face", StringComparison.Ordinal),
_ => false
};
+
+ private static bool IsSupportedCylindricalDimensionTarget(string featureId, IReadOnlyDictionary<string, FirmamentParsedOpEntry> opsByFeatureId)
+ {
+ if (!opsByFeatureId.TryGetValue(featureId, out var targetOp))
+ {
+ return false;
+ }
+
+ return targetOp.KnownKind == FirmamentKnownOpKind.Cylinder
+ || (targetOp.KnownKind == FirmamentKnownOpKind.Subtract
+ && targetOp.RawFields.TryGetValue("with", out var toolRaw)
+ && IsCylinderToolShape(toolRaw));
+ }
+
+ private static IReadOnlyDictionary<string, string> BuildDeclaredDatumKindsByLabel(IReadOnlyList<FirmamentParsedPmiEntry> entries)
+ {
+ var map = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+ foreach (var entry in entries.Where(entry => entry.Kind == FirmamentParsedPmiKind.Datum))
+ {
+ if (entry.RawFields.TryGetValue("label", out var label)
+ && !string.IsNullOrWhiteSpace(label)
+ && entry.RawFields.TryGetValue("datum_kind", out var datumKind)
+ && !string.IsNullOrWhiteSpace(datumKind)
+ && !map.ContainsKey(label))
+ {
+ map[label] = datumKind;
+ }
+ }
+
+ return map;
+ }
}
diff --git a/testdata/firmament/examples/m7_pmi_explicit_and_legacy_coexist.firmament b/testdata/firmament/examples/m7_pmi_explicit_and_legacy_coexist.firmament
new file mode 100644
index 00000000..99232a3d
--- /dev/null
+++ b/testdata/firmament/examples/m7_pmi_explicit_and_legacy_coexist.firmament
@@ -0,0 +1,31 @@
+firmament:
+ version: 1
+
+model:
+ name: m7_pmi_explicit_and_legacy_coexist
+ units: mm
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 80
+ 50
+ 20
+
+ -
+ op: subtract
+ id: hole
+ from: base
+ with:
+ op: cylinder
+ radius: 3
+ height: 24
+
+pmi[1]:
+ -
+ kind: dimension
+ dimension_kind: diameter
+ target: hole
+ value: 6
diff --git a/testdata/firmament/examples/m7_pmi_explicit_dimensions.firmament b/testdata/firmament/examples/m7_pmi_explicit_dimensions.firmament
new file mode 100644
index 00000000..eed76903
--- /dev/null
+++ b/testdata/firmament/examples/m7_pmi_explicit_dimensions.firmament
@@ -0,0 +1,47 @@
+firmament:
+ version: 1
+
+model:
+ name: m7_pmi_explicit_dimensions
+ units: mm
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 100
+ 60
+ 20
+
+ -
+ op: subtract
+ id: main_hole
+ from: base
+ with:
+ op: cylinder
+ radius: 5
+ height: 24
+ place:
+ on_face: base.top_face
+ centered_on: base.top_face
+
+pmi[3]:
+ -
+ kind: datum
+ datum_kind: plane
+ label: A
+ target: base.top_face
+
+ -
+ kind: dimension
+ dimension_kind: diameter
+ target: main_hole
+ value: 10
+
+ -
+ kind: dimension
+ dimension_kind: linear_distance_to_datum
+ target: main_hole
+ datum: A
+ value: 12
diff --git a/testdata/firmament/fixtures/m7e-invalid-pmi-dimension-invalid-target.firmament b/testdata/firmament/fixtures/m7e-invalid-pmi-dimension-invalid-target.firmament
new file mode 100644
index 00000000..4cc99808
--- /dev/null
+++ b/testdata/firmament/fixtures/m7e-invalid-pmi-dimension-invalid-target.firmament
@@ -0,0 +1,22 @@
+firmament:
+ version: 1
+
+model:
+ name: m7e_invalid_pmi_dimension_invalid_target
+ units: mm
+
+ops[1]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 40
+ 40
+ 20
+
+pmi[1]:
+ -
+ kind: dimension
+ dimension_kind: diameter
+ target: base
+ value: 10
diff --git a/testdata/firmament/fixtures/m7e-invalid-pmi-dimension-missing-datum.firmament b/testdata/firmament/fixtures/m7e-invalid-pmi-dimension-missing-datum.firmament
new file mode 100644
index 00000000..347cb8c8
--- /dev/null
+++ b/testdata/firmament/fixtures/m7e-invalid-pmi-dimension-missing-datum.firmament
@@ -0,0 +1,32 @@
+firmament:
+ version: 1
+
+model:
+ name: m7e_invalid_pmi_dimension_missing_datum
+ units: mm
+
+ops[2]:
+ -
+ op: box
+ id: base
+ size[3]:
+ 40
+ 40
+ 20
+
+ -
+ op: subtract
+ id: hole
+ from: base
+ with:
+ op: cylinder
+ radius: 4
+ height: 30
+
+pmi[1]:
+ -
+ kind: dimension
+ dimension_kind: linear_distance_to_datum
+ target: hole
+ datum: Z
+ value: 8