Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Normalize STEP plane angles to radians and canonicalize export context

Yuechen Lifdd13dc1cfb5
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
index a0c564fe..7914d3aa 100644
--- a/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
@@ -5,10 +5,10 @@ namespace Aetheris.Kernel.Core.Tests.Step242;
public sealed class Step242ConicalSurfaceRegressionTests
{
[Fact]
- public void Step242_ConicalSurfaceDecoder_AcceptsZeroRadiusWithDegreeSemiAngle()
+ public void Step242_ConicalSurfaceDecoder_AcceptsZeroRadiusWithRadianSemiAngle()
{
const string text = "ISO-10303-21;\nHEADER;\nENDSEC;\nDATA;\n"
- + "#10=CONICAL_SURFACE('',#20,0.,59.);\n"
+ + "#10=CONICAL_SURFACE('',#20,0.,1.029744258676654);\n"
+ "#20=AXIS2_PLACEMENT_3D('',#21,#22,#23);\n"
+ "#21=CARTESIAN_POINT('',(1.,2.,3.));\n"
+ "#22=DIRECTION('',(0.,0.,1.));\n"
@@ -27,7 +27,7 @@ public sealed class Step242ConicalSurfaceRegressionTests
Assert.Equal(1d, cone.Value.Apex.X, 9);
Assert.Equal(2d, cone.Value.Apex.Y, 9);
Assert.Equal(3d, cone.Value.Apex.Z, 9);
- Assert.Equal(59d * (double.Pi / 180d), cone.Value.SemiAngleRadians, 12);
+ Assert.Equal(1.029744258676654d, cone.Value.SemiAngleRadians, 12);
}
[Theory]
@@ -146,4 +146,46 @@ public sealed class Step242ConicalSurfaceRegressionTests
Assert.Equal(first.FirstDiagnostic.MessagePrefix, second.FirstDiagnostic.MessagePrefix);
}
+
+ [Fact]
+ public void Step242_ConicalSurfaceImport_DegreeContextFromGlobalUnits_NormalizesToRadians()
+ {
+ var fixturePath = Path.Combine(Step242CorpusManifestRunner.RepoRoot(), "testdata", "step242", "nist", "CTC", "nist_ctc_01_asme1_ap242-e1.stp");
+ var source = File.ReadAllText(fixturePath);
+
+ var import = Step242Importer.ImportBody(source);
+ Assert.True(import.IsSuccess);
+
+ var cones = import.Value.Geometry.Surfaces
+ .Select(surface => surface.Value)
+ .Where(surface => surface.Kind == Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.Cone)
+ .Select(surface => surface.Cone)
+ .Where(cone => cone.HasValue)
+ .Select(cone => cone!.Value.SemiAngleRadians)
+ .ToArray();
+
+ Assert.NotEmpty(cones);
+ Assert.Contains(cones, angle => double.Abs(angle - 1.02974425867665d) <= 1e-6d);
+ }
+
+ [Fact]
+ public void Step242_ConicalSurfaceImport_RadianContextFromGlobalUnits_RemainsRadians()
+ {
+ var fixturePath = Path.Combine(Step242CorpusManifestRunner.RepoRoot(), "testdata", "step242", "nist", "STC", "nist_stc_09_asme1_ap242-e3.stp");
+ var source = File.ReadAllText(fixturePath);
+
+ var import = Step242Importer.ImportBody(source);
+ Assert.True(import.IsSuccess);
+
+ var cones = import.Value.Geometry.Surfaces
+ .Select(surface => surface.Value)
+ .Where(surface => surface.Kind == Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.Cone)
+ .Select(surface => surface.Cone)
+ .Where(cone => cone.HasValue)
+ .Select(cone => cone!.Value.SemiAngleRadians)
+ .ToArray();
+
+ Assert.NotEmpty(cones);
+ Assert.Contains(cones, angle => double.Abs(angle - 0.7853981634d) <= 1e-6d);
+ }
}
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242ExporterTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242ExporterTests.cs
index b6fb62d2..c5584d49 100644
--- a/Aetheris.Kernel.Core.Tests/Step242/Step242ExporterTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242ExporterTests.cs
@@ -81,7 +81,7 @@ END-ISO-10303-21;";
}
[Fact]
- public void ExportBody_ImportedConicalFace_EmitsConicalSurface()
+ public void ExportBody_ImportedConicalFace_EmitsConicalSurfaceWithCanonicalRadianSemiAngle()
{
const string conicalFace = @"ISO-10303-21;
HEADER;
@@ -131,11 +131,11 @@ END-ISO-10303-21;";
var semiAngles = ExtractConicalSurfaceSemiAngles(export.Value);
var semiAngle = Assert.Single(semiAngles);
- Assert.Equal(45d, semiAngle, 9);
+ Assert.Equal(double.Pi / 4d, semiAngle, 9);
}
[Fact]
- public void ExportBody_Ctc01RoundTrip_ConicalSurfaceSemiAngle_StaysInExpectedDegreeConvention()
+ public void ExportBody_Ctc01RoundTrip_ConicalSurfaceSemiAngle_IsCanonicalRadiansConvention()
{
var fixturePath = Path.Combine(Step242CorpusManifestRunner.RepoRoot(), "testdata", "step242", "nist", "CTC", "nist_ctc_01_asme1_ap242-e1.stp");
var source = File.ReadAllText(fixturePath);
@@ -154,10 +154,24 @@ END-ISO-10303-21;";
for (var i = 0; i < sourceSemiAngles.Count; i++)
{
- Assert.Equal(sourceSemiAngles[i], exportedSemiAngles[i], 9);
+ Assert.Equal(sourceSemiAngles[i] * (double.Pi / 180d), exportedSemiAngles[i], 9);
}
}
+
+ [Fact]
+ public void ExportBody_EmitsCanonicalRadianPlaneAngleUnitContext()
+ {
+ var boxResult = BrepPrimitives.CreateBox(4d, 6d, 8d);
+ Assert.True(boxResult.IsSuccess);
+
+ var export = Step242Exporter.ExportBody(boxResult.Value);
+ Assert.True(export.IsSuccess);
+
+ Assert.Contains("PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.)", export.Value, StringComparison.Ordinal);
+ Assert.DoesNotContain("CONVERSION_BASED_UNIT('DEGREE'", export.Value, StringComparison.Ordinal);
+ }
+
[Fact]
public void ExportBody_ImportedCircularEdge_EmitsCircleCurve()
{
diff --git a/Aetheris.Kernel.Core/Step242/Step242Exporter.cs b/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
index 9dc494cf..a53d4b3b 100644
--- a/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
@@ -126,7 +126,10 @@ public static class Step242Exporter
var definitionContextId = writer.AddEntity("PRODUCT_DEFINITION_CONTEXT", Step242TextWriter.String("design"), Step242TextWriter.Ref(appContextId), Step242TextWriter.String("design"));
var definitionId = writer.AddEntity("PRODUCT_DEFINITION", Step242TextWriter.String(""), Step242TextWriter.String(""), Step242TextWriter.Ref(formationId), Step242TextWriter.Ref(definitionContextId));
var shapeId = writer.AddEntity("PRODUCT_DEFINITION_SHAPE", Step242TextWriter.String(""), Step242TextWriter.String(""), Step242TextWriter.Ref(definitionId));
- var repContextId = writer.AddEntity("GEOMETRIC_REPRESENTATION_CONTEXT", "3");
+ var lengthUnitId = writer.AddRawEntity("(LENGTH_UNIT()NAMED_UNIT(*)SI_UNIT(.MILLI.,.METRE.))");
+ var planeAngleUnitId = writer.AddRawEntity("(NAMED_UNIT(*)PLANE_ANGLE_UNIT()SI_UNIT($,.RADIAN.))");
+ var solidAngleUnitId = writer.AddRawEntity("(NAMED_UNIT(*)SI_UNIT($,.STERADIAN.)SOLID_ANGLE_UNIT())");
+ var repContextId = writer.AddRawEntity($"(GEOMETRIC_REPRESENTATION_CONTEXT(3)GLOBAL_UNIT_ASSIGNED_CONTEXT(({lengthUnitId},{planeAngleUnitId},{solidAngleUnitId}))REPRESENTATION_CONTEXT('3','3D'))");
var shapeRepresentationId = writer.AddEntity("SHAPE_REPRESENTATION", Step242TextWriter.String(options.ProductName), Step242TextWriter.List(brepId), Step242TextWriter.Ref(repContextId));
writer.AddEntity("SHAPE_DEFINITION_REPRESENTATION", Step242TextWriter.Ref(shapeId), Step242TextWriter.Ref(shapeRepresentationId));
@@ -154,8 +157,7 @@ public static class Step242Exporter
private static string BuildCone(Step242TextWriter writer, ConeSurface cone)
{
var axisPlacementId = BuildAxisPlacement(writer, cone.Apex, cone.Axis, BuildPerpendicularReferenceAxis(cone.Axis));
- var semiAngleDegrees = cone.SemiAngleRadians * (180d / double.Pi);
- return writer.AddEntity("CONICAL_SURFACE", "$", Step242TextWriter.Ref(axisPlacementId), Step242TextWriter.Number(0d), Step242TextWriter.Number(semiAngleDegrees));
+ return writer.AddEntity("CONICAL_SURFACE", "$", Step242TextWriter.Ref(axisPlacementId), Step242TextWriter.Number(0d), Step242TextWriter.Number(cone.SemiAngleRadians));
}
private static KernelResult<string> BuildSurface(Step242TextWriter writer, SurfaceGeometry surface, FaceId faceId)
diff --git a/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs b/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs
index ebe7cb62..2062576f 100644
--- a/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs
@@ -651,7 +651,7 @@ internal static class Step242SubsetDecoder
return KernelResult<ConeSurface>.Failure(semiAngleResult.Diagnostics);
}
- var normalizedSemiAngleResult = NormalizeConicalSemiAngle(semiAngleResult.Value);
+ var normalizedSemiAngleResult = NormalizeConicalSemiAngle(document, semiAngleResult.Value);
if (!normalizedSemiAngleResult.IsSuccess)
{
return KernelResult<ConeSurface>.Failure(normalizedSemiAngleResult.Diagnostics);
@@ -671,27 +671,20 @@ internal static class Step242SubsetDecoder
}
}
- private static KernelResult<double> NormalizeConicalSemiAngle(double rawSemiAngle)
+ private static KernelResult<double> NormalizeConicalSemiAngle(Step242ParsedDocument document, double rawSemiAngle)
{
if (!double.IsFinite(rawSemiAngle) || rawSemiAngle <= 0d)
{
return FailureNumberCode("CONICAL_SURFACE semi-angle must be greater than zero.", "Importer.Geometry.Cone");
}
- if (rawSemiAngle < (double.Pi / 2d))
+ var normalized = rawSemiAngle * document.PlaneAngleToRadiansScale;
+ if (!double.IsFinite(normalized) || normalized <= 0d || normalized >= (double.Pi / 2d))
{
- return KernelResult<double>.Success(rawSemiAngle);
+ return FailureNumberCode("CONICAL_SURFACE semi-angle must be in the range (0, pi/2) radians after applying plane angle unit context.", "Importer.Geometry.Cone");
}
- if (rawSemiAngle < 90d)
- {
- // Compatibility heuristic: observed NIST/AP242 corpus inputs contain degree-form cone semi-angle values
- // (for example near 59). This normalization is intentionally limited and is not a claim that AP242
- // generically encodes CONICAL_SURFACE semi-angle in degrees.
- return KernelResult<double>.Success(rawSemiAngle * (double.Pi / 180d));
- }
-
- return FailureNumberCode("CONICAL_SURFACE semi-angle must be in the range (0, pi/2) or (0, 90) degrees.", "Importer.Geometry.Cone");
+ return KernelResult<double>.Success(normalized);
}
private static KernelResult<(Point3D Origin, Direction3D Axis, Direction3D ReferenceAxis)> ReadAxis2Placement3D(
diff --git a/Aetheris.Kernel.Core/Step242/Step242SubsetParser.cs b/Aetheris.Kernel.Core/Step242/Step242SubsetParser.cs
index 187ff93a..7cf28a1a 100644
--- a/Aetheris.Kernel.Core/Step242/Step242SubsetParser.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242SubsetParser.cs
@@ -584,10 +584,13 @@ internal sealed class Step242ParsedDocument
{
Entities = entities;
_entitiesById = entities.ToDictionary(e => e.Id);
+ PlaneAngleToRadiansScale = ResolvePlaneAngleToRadiansScale();
}
public IReadOnlyList<Step242ParsedEntity> Entities { get; }
+ public double PlaneAngleToRadiansScale { get; }
+
public KernelResult<Step242ParsedEntity> TryGetEntity(int id, string? expectedName = null)
{
if (!_entitiesById.TryGetValue(id, out var entity))
@@ -607,6 +610,89 @@ internal sealed class Step242ParsedDocument
KernelResult<Step242ParsedEntity>.Failure([
new KernelDiagnostic(KernelDiagnosticCode.NotImplemented, KernelDiagnosticSeverity.Error, message, source)
]);
+
+ private double ResolvePlaneAngleToRadiansScale()
+ {
+ foreach (var entity in Entities)
+ {
+ var unitContext = Step242SubsetDecoder.TryGetConstructor(entity.Instance, "GLOBAL_UNIT_ASSIGNED_CONTEXT");
+ if (unitContext is null || unitContext.Arguments.Count == 0 || unitContext.Arguments[0] is not Step242ListValue unitList)
+ {
+ continue;
+ }
+
+ foreach (var unitValue in unitList.Items)
+ {
+ if (unitValue is not Step242EntityReference unitRef)
+ {
+ continue;
+ }
+
+ if (TryResolvePlaneAngleUnitScale(unitRef.TargetId, new HashSet<int>(), out var scale))
+ {
+ return scale;
+ }
+ }
+ }
+
+ return 1d;
+ }
+
+ private bool TryResolvePlaneAngleUnitScale(int unitEntityId, HashSet<int> visited, out double scale)
+ {
+ scale = default;
+ if (!visited.Add(unitEntityId) || !_entitiesById.TryGetValue(unitEntityId, out var unitEntity))
+ {
+ return false;
+ }
+
+ if (Step242SubsetDecoder.TryGetConstructor(unitEntity.Instance, "PLANE_ANGLE_UNIT") is null)
+ {
+ return false;
+ }
+
+ var siUnit = Step242SubsetDecoder.TryGetConstructor(unitEntity.Instance, "SI_UNIT");
+ if (siUnit is not null
+ && siUnit.Arguments.Count >= 2
+ && siUnit.Arguments[1] is Step242EnumValue siName
+ && string.Equals(siName.Value, "RADIAN", StringComparison.Ordinal))
+ {
+ scale = 1d;
+ return true;
+ }
+
+ var conversionBasedUnit = Step242SubsetDecoder.TryGetConstructor(unitEntity.Instance, "CONVERSION_BASED_UNIT");
+ if (conversionBasedUnit is null
+ || conversionBasedUnit.Arguments.Count < 2
+ || conversionBasedUnit.Arguments[1] is not Step242EntityReference conversionRef
+ || !_entitiesById.TryGetValue(conversionRef.TargetId, out var conversionEntity))
+ {
+ return false;
+ }
+
+ var conversionConstructor = conversionEntity.Instance.PrimaryConstructor;
+ if (conversionConstructor.Arguments.Count < 2)
+ {
+ return false;
+ }
+
+ if (conversionConstructor.Arguments[0] is not Step242TypedValue typedMeasure
+ || !string.Equals(typedMeasure.Name, "PLANE_ANGLE_MEASURE", StringComparison.Ordinal)
+ || typedMeasure.Arguments.Count != 1
+ || typedMeasure.Arguments[0] is not Step242NumberValue baseMagnitude
+ || conversionConstructor.Arguments[1] is not Step242EntityReference baseUnitRef)
+ {
+ return false;
+ }
+
+ if (!TryResolvePlaneAngleUnitScale(baseUnitRef.TargetId, visited, out var baseScale))
+ {
+ return false;
+ }
+
+ scale = baseMagnitude.Value * baseScale;
+ return true;
+ }
}
internal abstract record Step242Value;
diff --git a/Aetheris.Kernel.Core/Step242/Step242TextWriter.cs b/Aetheris.Kernel.Core/Step242/Step242TextWriter.cs
index 87ef989a..62264209 100644
--- a/Aetheris.Kernel.Core/Step242/Step242TextWriter.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242TextWriter.cs
@@ -14,6 +14,13 @@ internal sealed class Step242TextWriter
return id;
}
+ public string AddRawEntity(string entityInstance)
+ {
+ var id = $"#{_entities.Count + 1}";
+ _entities.Add($"{id}={entityInstance};");
+ return id;
+ }
+
public string Build(string applicationName)
{
var sb = new StringBuilder();