Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Handle AXIS2 default ref-direction parallelism deterministically

Yuechen Li81605abccd9e
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
index d9491de1..5fd590e4 100644
--- a/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
@@ -305,11 +305,87 @@ public sealed class Step242ConicalSurfaceRegressionTests
var second = Step242CorpusManifestRunner.RunOne(entry);
Assert.DoesNotContain("AXIS2_PLACEMENT_3D ref direction: expected entity reference argument.", first.FirstDiagnostic.MessagePrefix, StringComparison.Ordinal);
- Assert.Equal("importer-geometry", first.FirstFailureLayer);
- Assert.Equal("Importer.Geometry.Circle", first.FirstDiagnostic.Source);
- Assert.Equal("AXIS2_PLACEMENT_3D axis and ref direction must not be parallel.", first.FirstDiagnostic.MessagePrefix);
+ Assert.NotEqual("AXIS2_PLACEMENT_3D axis and ref direction must not be parallel.", first.FirstDiagnostic.MessagePrefix);
Assert.Equal(first.FirstFailureLayer, second.FirstFailureLayer);
Assert.Equal(first.FirstDiagnostic.Source, second.FirstDiagnostic.Source);
Assert.Equal(first.FirstDiagnostic.MessagePrefix, second.FirstDiagnostic.MessagePrefix);
}
+
+ [Fact]
+ public void Step242_Axis2Placement3D_DefaultedRefDirectionParallelToAxis_UsesDeterministicPerpendicularFallback()
+ {
+ const string text = "ISO-10303-21;\nHEADER;\nENDSEC;\nDATA;\n"
+ + "#1=MANIFOLD_SOLID_BREP('solid',#2);\n"
+ + "#2=CLOSED_SHELL($,(#3));\n"
+ + "#3=ADVANCED_FACE((#4),#5,.T.);\n"
+ + "#4=FACE_OUTER_BOUND($,#6,.T.);\n"
+ + "#5=PLANE($,#30);\n"
+ + "#6=EDGE_LOOP($,(#7));\n"
+ + "#7=ORIENTED_EDGE($,$,$,#8,.T.);\n"
+ + "#8=EDGE_CURVE($,#9,#9,#10,.T.);\n"
+ + "#9=VERTEX_POINT($,#11);\n"
+ + "#10=CIRCLE($,#31,1.0);\n"
+ + "#11=CARTESIAN_POINT($,(1,0,0));\n"
+ + "#30=AXIS2_PLACEMENT_3D($,#12,#13,#14);\n"
+ + "#31=AXIS2_PLACEMENT_3D($,#12,#15,$);\n"
+ + "#12=CARTESIAN_POINT($,(0,0,0));\n"
+ + "#13=DIRECTION($,(0,0,1));\n"
+ + "#14=DIRECTION($,(1,0,0));\n"
+ + "#15=DIRECTION($,(1,0,0));\n"
+ + "ENDSEC;\nEND-ISO-10303-21;";
+
+ var first = Step242Importer.ImportBody(text);
+ var second = Step242Importer.ImportBody(text);
+
+ Assert.True(first.IsSuccess);
+ Assert.True(second.IsSuccess);
+
+ var firstCircle = first.Value.Geometry.Curves
+ .Select(curve => curve.Value)
+ .Single(curve => curve.Kind == Aetheris.Kernel.Core.Geometry.CurveGeometryKind.Circle3)
+ .Circle3!.Value;
+
+ var secondCircle = second.Value.Geometry.Curves
+ .Select(curve => curve.Value)
+ .Single(curve => curve.Kind == Aetheris.Kernel.Core.Geometry.CurveGeometryKind.Circle3)
+ .Circle3!.Value;
+
+ Assert.True(double.Abs(firstCircle.Normal.ToVector().Dot(firstCircle.XAxis.ToVector())) < 1e-12d);
+ Assert.True(double.Abs(secondCircle.Normal.ToVector().Dot(secondCircle.XAxis.ToVector())) < 1e-12d);
+ Assert.Equal(firstCircle.XAxis.ToVector().X, secondCircle.XAxis.ToVector().X, 12);
+ Assert.Equal(firstCircle.XAxis.ToVector().Y, secondCircle.XAxis.ToVector().Y, 12);
+ Assert.Equal(firstCircle.XAxis.ToVector().Z, secondCircle.XAxis.ToVector().Z, 12);
+ }
+
+ [Fact]
+ public void Step242_Axis2Placement3D_ExplicitParallelAxisAndRefDirection_RemainsInvalid()
+ {
+ const string text = "ISO-10303-21;\nHEADER;\nENDSEC;\nDATA;\n"
+ + "#1=MANIFOLD_SOLID_BREP('solid',#2);\n"
+ + "#2=CLOSED_SHELL($,(#3));\n"
+ + "#3=ADVANCED_FACE((#4),#5,.T.);\n"
+ + "#4=FACE_OUTER_BOUND($,#6,.T.);\n"
+ + "#5=PLANE($,#30);\n"
+ + "#6=EDGE_LOOP($,(#7));\n"
+ + "#7=ORIENTED_EDGE($,$,$,#8,.T.);\n"
+ + "#8=EDGE_CURVE($,#9,#9,#10,.T.);\n"
+ + "#9=VERTEX_POINT($,#11);\n"
+ + "#10=CIRCLE($,#31,1.0);\n"
+ + "#11=CARTESIAN_POINT($,(1,0,0));\n"
+ + "#30=AXIS2_PLACEMENT_3D($,#12,#13,#14);\n"
+ + "#31=AXIS2_PLACEMENT_3D($,#12,#15,#16);\n"
+ + "#12=CARTESIAN_POINT($,(0,0,0));\n"
+ + "#13=DIRECTION($,(0,0,1));\n"
+ + "#14=DIRECTION($,(1,0,0));\n"
+ + "#15=DIRECTION($,(1,0,0));\n"
+ + "#16=DIRECTION($,(1,0,0));\n"
+ + "ENDSEC;\nEND-ISO-10303-21;";
+
+ var import = Step242Importer.ImportBody(text);
+
+ Assert.False(import.IsSuccess);
+ var diagnostic = Assert.Single(import.Diagnostics);
+ Assert.Equal("Importer.Geometry.Circle", diagnostic.Source);
+ Assert.Equal("AXIS2_PLACEMENT_3D axis and ref direction must not be parallel.", diagnostic.Message);
+ }
}
diff --git a/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs b/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs
index 19d69742..130f22d9 100644
--- a/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs
@@ -675,38 +675,83 @@ internal static class Step242SubsetDecoder
return KernelResult<(Point3D, Direction3D, Direction3D)>.Failure(refDirResult.Diagnostics);
}
- if (double.Abs(axisResult.Value.ToVector().Dot(refDirResult.Value.ToVector())) >= 1d - 1e-12d)
+ var axis = axisResult.Value.Direction;
+ var referenceAxis = refDirResult.Value.Direction;
+ if (double.Abs(axis.ToVector().Dot(referenceAxis.ToVector())) >= 1d - 1e-12d)
{
- return FailureAxisPlacement("AXIS2_PLACEMENT_3D axis and ref direction must not be parallel.", geometrySource);
+ if (refDirResult.Value.IsDefaulted)
+ {
+ var fallbackResult = BuildDeterministicPerpendicularDirection(axis, "AXIS2_PLACEMENT_3D ref direction", geometrySource);
+ if (!fallbackResult.IsSuccess)
+ {
+ return KernelResult<(Point3D, Direction3D, Direction3D)>.Failure(fallbackResult.Diagnostics);
+ }
+
+ referenceAxis = fallbackResult.Value;
+ }
+ else
+ {
+ return FailureAxisPlacement("AXIS2_PLACEMENT_3D axis and ref direction must not be parallel.", geometrySource);
+ }
}
- return KernelResult<(Point3D, Direction3D, Direction3D)>.Success((originResult.Value, axisResult.Value, refDirResult.Value));
+ return KernelResult<(Point3D, Direction3D, Direction3D)>.Success((originResult.Value, axis, referenceAxis));
}
- private static KernelResult<Direction3D> ReadPlacementDirection(Step242ParsedDocument document, Step242ParsedEntity placementEntity, int argumentIndex, string context, Vector3D defaultDirection)
+ private static KernelResult<PlacementDirectionReadResult> ReadPlacementDirection(Step242ParsedDocument document, Step242ParsedEntity placementEntity, int argumentIndex, string context, Vector3D defaultDirection)
{
if (argumentIndex < 0 || argumentIndex >= placementEntity.Arguments.Count)
{
- return FailureDirection($"{context}: missing argument at index {argumentIndex}.", $"Entity:{placementEntity.Id}");
+ return FailurePlacementDirection($"{context}: missing argument at index {argumentIndex}.", $"Entity:{placementEntity.Id}");
}
if (placementEntity.Arguments[argumentIndex] is Step242OmittedValue)
{
- return KernelResult<Direction3D>.Success(Direction3D.Create(defaultDirection));
+ return KernelResult<PlacementDirectionReadResult>.Success(new PlacementDirectionReadResult(Direction3D.Create(defaultDirection), IsDefaulted: true));
}
if (placementEntity.Arguments[argumentIndex] is not Step242EntityReference reference)
{
- return FailureDirection($"{context}: expected entity reference argument.", $"Entity:{placementEntity.Id}");
+ return FailurePlacementDirection($"{context}: expected entity reference argument.", $"Entity:{placementEntity.Id}");
}
var directionEntityResult = document.TryGetEntity(reference.TargetId, "DIRECTION");
if (!directionEntityResult.IsSuccess)
{
- return KernelResult<Direction3D>.Failure(directionEntityResult.Diagnostics);
+ return KernelResult<PlacementDirectionReadResult>.Failure(directionEntityResult.Diagnostics);
+ }
+
+ var directionResult = ReadDirection(directionEntityResult.Value, context);
+ if (!directionResult.IsSuccess)
+ {
+ return KernelResult<PlacementDirectionReadResult>.Failure(directionResult.Diagnostics);
+ }
+
+ return KernelResult<PlacementDirectionReadResult>.Success(new PlacementDirectionReadResult(directionResult.Value, IsDefaulted: false));
+ }
+
+ private static KernelResult<Direction3D> BuildDeterministicPerpendicularDirection(Direction3D axis, string context, string source)
+ {
+ var axisVector = axis.ToVector();
+ var candidateSeeds = new[]
+ {
+ new Vector3D(1d, 0d, 0d),
+ new Vector3D(0d, 1d, 0d),
+ new Vector3D(0d, 0d, 1d)
+ }
+ .OrderBy(seed => double.Abs(seed.Dot(axisVector)))
+ .ToArray();
+
+ foreach (var seed in candidateSeeds)
+ {
+ var projected = seed - (axisVector * seed.Dot(axisVector));
+ if (Direction3D.TryCreate(projected, out var direction))
+ {
+ return KernelResult<Direction3D>.Success(direction);
+ }
}
- return ReadDirection(directionEntityResult.Value, context);
+ return FailureDirection($"{context}: unable to build a deterministic perpendicular direction from placement axis.", source);
}
private static KernelResult<double> ReadNumberArgument(Step242ParsedEntity entity, int argumentIndex, string context, string source)
@@ -1105,6 +1150,8 @@ internal static class Step242SubsetDecoder
private static KernelResult<Direction3D> FailureDirection(string message, string source) => Failure<Direction3D>(message, source);
+ private static KernelResult<PlacementDirectionReadResult> FailurePlacementDirection(string message, string source) => Failure<PlacementDirectionReadResult>(message, source);
+
private static KernelResult<PlaneSurface> FailurePlane(string message, string source) => Failure<PlaneSurface>(message, source);
private static KernelResult<Circle3Curve> FailureCircle(string message, string source) => Failure<Circle3Curve>(KernelDiagnosticCode.InvalidArgument, message, source);
@@ -1138,4 +1185,6 @@ internal static class Step242SubsetDecoder
private static KernelResult<T> Failure<T>(KernelDiagnosticCode code, string message, string source) =>
KernelResult<T>.Failure([new KernelDiagnostic(code, KernelDiagnosticSeverity.Error, message, source)]);
+
+ private readonly record struct PlacementDirectionReadResult(Direction3D Direction, bool IsDefaulted);
}