Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Fix AXIS2_PLACEMENT_3D defaults and cone placement semantics

Yuechen Liadb4a72849db
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
index 4a423fad..d9491de1 100644
--- a/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242ConicalSurfaceRegressionTests.cs
@@ -1,9 +1,56 @@
using Aetheris.Kernel.Core.Step242;
+using System.Text.RegularExpressions;
namespace Aetheris.Kernel.Core.Tests.Step242;
public sealed class Step242ConicalSurfaceRegressionTests
{
+ [Fact]
+ public void Step242_Axis2Placement3D_RefDirectionOmitted_UsesDefaultPlacementDirection()
+ {
+ 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($,#20);\n"
+ + "#6=EDGE_LOOP($,(#7,#8,#9,#10));\n"
+ + "#7=ORIENTED_EDGE($,$,$,#30,.T.);\n"
+ + "#8=ORIENTED_EDGE($,$,$,#31,.T.);\n"
+ + "#9=ORIENTED_EDGE($,$,$,#32,.T.);\n"
+ + "#10=ORIENTED_EDGE($,$,$,#33,.T.);\n"
+ + "#30=EDGE_CURVE($,#40,#41,#50,.T.);\n"
+ + "#31=EDGE_CURVE($,#41,#42,#51,.T.);\n"
+ + "#32=EDGE_CURVE($,#42,#43,#52,.T.);\n"
+ + "#33=EDGE_CURVE($,#43,#40,#53,.T.);\n"
+ + "#40=VERTEX_POINT($,#60);\n"
+ + "#41=VERTEX_POINT($,#61);\n"
+ + "#42=VERTEX_POINT($,#62);\n"
+ + "#43=VERTEX_POINT($,#63);\n"
+ + "#50=LINE($,#60,#70);\n"
+ + "#51=LINE($,#61,#71);\n"
+ + "#52=LINE($,#62,#72);\n"
+ + "#53=LINE($,#63,#73);\n"
+ + "#60=CARTESIAN_POINT($,(0.,0.,0.));\n"
+ + "#61=CARTESIAN_POINT($,(1.,0.,0.));\n"
+ + "#62=CARTESIAN_POINT($,(1.,1.,0.));\n"
+ + "#63=CARTESIAN_POINT($,(0.,1.,0.));\n"
+ + "#70=VECTOR($,#80,1.);\n"
+ + "#71=VECTOR($,#81,1.);\n"
+ + "#72=VECTOR($,#82,1.);\n"
+ + "#73=VECTOR($,#83,1.);\n"
+ + "#80=DIRECTION($,(1.,0.,0.));\n"
+ + "#81=DIRECTION($,(0.,1.,0.));\n"
+ + "#82=DIRECTION($,(-1.,0.,0.));\n"
+ + "#83=DIRECTION($,(0.,-1.,0.));\n"
+ + "#20=AXIS2_PLACEMENT_3D('',#60,#21,$);\n"
+ + "#21=DIRECTION('',(0.,0.,1.));\n"
+ + "ENDSEC;\nEND-ISO-10303-21;";
+
+ var import = Step242Importer.ImportBody(text);
+ Assert.True(import.IsSuccess);
+ }
+
[Fact]
public void Step242_ConicalSurfaceDecoder_AcceptsZeroRadiusWithRadianSemiAngle()
{
@@ -193,4 +240,76 @@ public sealed class Step242ConicalSurfaceRegressionTests
Assert.NotEmpty(cones);
Assert.Contains(cones, angle => double.Abs(angle - 0.7853981634d) <= 1e-6d);
}
+
+ [Fact]
+ public void Step242_ConicalSurface_WithNonZeroPlacementRadius_PreservesStoredPlacementSemanticsThroughRoundTrip()
+ {
+ 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=CONICAL_SURFACE($,#20,2.,0.7853981633974483);\n"
+ + "#6=EDGE_LOOP($,(#10));\n"
+ + "#10=ORIENTED_EDGE($,$,$,#11,.T.);\n"
+ + "#11=EDGE_CURVE($,#12,#13,#14,.T.);\n"
+ + "#12=VERTEX_POINT($,#30);\n"
+ + "#13=VERTEX_POINT($,#31);\n"
+ + "#14=LINE($,#30,#40);\n"
+ + "#20=AXIS2_PLACEMENT_3D($,#21,#22,#23);\n"
+ + "#21=CARTESIAN_POINT($,(0.,0.,5.));\n"
+ + "#22=DIRECTION($,(0.,0.,1.));\n"
+ + "#23=DIRECTION($,(1.,0.,0.));\n"
+ + "#30=CARTESIAN_POINT($,(2.,0.,5.));\n"
+ + "#31=CARTESIAN_POINT($,(2.,0.,6.));\n"
+ + "#40=VECTOR($,#41,1.);\n"
+ + "#41=DIRECTION($,(0.,0.,1.));\n"
+ + "ENDSEC;\nEND-ISO-10303-21;";
+
+ var import = Step242Importer.ImportBody(text);
+ Assert.True(import.IsSuccess);
+
+ var cone = import.Value.Geometry.Surfaces
+ .Select(surface => surface.Value)
+ .Where(surface => surface.Kind == Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.Cone)
+ .Select(surface => surface.Cone)
+ .Where(value => value.HasValue)
+ .Select(value => value!.Value)
+ .Single();
+
+ Assert.Equal(5d, cone.PlacementOrigin.Z, 9);
+ Assert.Equal(2d, cone.PlacementRadius, 9);
+ Assert.Equal(3d, cone.Apex.Z, 9);
+
+ var export = Step242Exporter.ExportBody(import.Value);
+ Assert.True(export.IsSuccess);
+ Assert.Contains("CONICAL_SURFACE", export.Value, StringComparison.Ordinal);
+ Assert.Matches(new Regex(@"CONICAL_SURFACE\([^,]*,[^,]*,2(?:\.0*)?,", RegexOptions.CultureInvariant), export.Value);
+ }
+
+ [Fact]
+ public void Step242_NistStc07_AdvancesPastAxis2PlacementRefDirectionFirstBlocker_AndRemainsDeterministic()
+ {
+ const string relativePath = "testdata/step242/nist/STC/nist_stc_07_asme1_ap242-e3.stp";
+ var entry = new Step242CorpusManifestEntry(
+ Id: Path.GetFileNameWithoutExtension(relativePath),
+ Path: relativePath,
+ Group: "nist-axis2-placement-regression",
+ Notes: "regression",
+ ExpectedFirstDiagnostic: null,
+ ExpectHashStableAfterCanonicalization: null,
+ ExpectTopologyCounts: null,
+ ExpectGeometryKinds: null);
+
+ var first = Step242CorpusManifestRunner.RunOne(entry);
+ 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.Equal(first.FirstFailureLayer, second.FirstFailureLayer);
+ Assert.Equal(first.FirstDiagnostic.Source, second.FirstDiagnostic.Source);
+ Assert.Equal(first.FirstDiagnostic.MessagePrefix, second.FirstDiagnostic.MessagePrefix);
+ }
}
diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs
index 312aca12..78e0997e 100644
--- a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs
+++ b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs
@@ -281,14 +281,13 @@ public static class BrepDisplayTessellator
private static KernelResult<DisplayFaceMeshPatch> TessellateConeFace(BrepBody body, FaceId faceId, ConeSurface cone, DisplayTessellationOptions options)
{
- var axis = cone.Axis.ToVector();
var parameters = GetRevolvedFaceParameters(
body,
faceId,
options,
radiusHint: 1d,
allowThreeCoedgeConeTopology: true,
- axialParameterFromPoint: point => (point - cone.Apex).Dot(axis));
+ axialParameterFromPoint: cone.AxialParameterFromPoint);
if (!parameters.IsSuccess)
{
return KernelResult<DisplayFaceMeshPatch>.Failure(parameters.Diagnostics);
diff --git a/Aetheris.Kernel.Core/Geometry/Surfaces/ConeSurface.cs b/Aetheris.Kernel.Core/Geometry/Surfaces/ConeSurface.cs
index b60b3117..0bef52b4 100644
--- a/Aetheris.Kernel.Core/Geometry/Surfaces/ConeSurface.cs
+++ b/Aetheris.Kernel.Core/Geometry/Surfaces/ConeSurface.cs
@@ -18,25 +18,37 @@ public readonly record struct ConeSurface
throw new ArgumentOutOfRangeException(nameof(semiAngleRadians), "Semi-angle must be finite and in the range (0, pi/2). ");
}
- var axisVector = axis.ToVector();
- var reference = referenceAxis.ToVector();
- var projected = reference - (axisVector * reference.Dot(axisVector));
+ Apex = apex;
+ Axis = axis;
+ SemiAngleRadians = semiAngleRadians;
+ PlacementOrigin = apex;
+ PlacementRadius = 0d;
+ ReferenceAxis = referenceAxis;
+ _xAxis = ResolveXAxis(axis, referenceAxis);
+ _yAxis = ResolveYAxis(axis, _xAxis);
+ }
- if (!Direction3D.TryCreate(projected, out var xAxis))
+ public ConeSurface(Point3D placementOrigin, Direction3D axis, double placementRadius, double semiAngleRadians, Direction3D referenceAxis)
+ {
+ if (!double.IsFinite(placementRadius) || placementRadius < 0d)
{
- throw new ArgumentOutOfRangeException(nameof(referenceAxis), "Reference axis must not be parallel to cone axis.");
+ throw new ArgumentOutOfRangeException(nameof(placementRadius), "Placement radius must be finite and greater than or equal to zero.");
}
- if (!Direction3D.TryCreate(axisVector.Cross(xAxis.ToVector()), out var yAxis))
+ if (!double.IsFinite(semiAngleRadians) || semiAngleRadians <= 0d || semiAngleRadians >= (double.Pi / 2d))
{
- throw new ArgumentOutOfRangeException(nameof(axis), "Axis must define a valid cone frame.");
+ throw new ArgumentOutOfRangeException(nameof(semiAngleRadians), "Semi-angle must be finite and in the range (0, pi/2). ");
}
- Apex = apex;
+ var offset = axis.ToVector() * (placementRadius / double.Tan(semiAngleRadians));
+ Apex = placementOrigin - offset;
Axis = axis;
SemiAngleRadians = semiAngleRadians;
- _xAxis = xAxis;
- _yAxis = yAxis;
+ PlacementOrigin = placementOrigin;
+ PlacementRadius = placementRadius;
+ ReferenceAxis = referenceAxis;
+ _xAxis = ResolveXAxis(axis, referenceAxis);
+ _yAxis = ResolveYAxis(axis, _xAxis);
}
public Point3D Apex { get; }
@@ -45,6 +57,18 @@ public readonly record struct ConeSurface
public double SemiAngleRadians { get; }
+ public Direction3D ReferenceAxis { get; }
+
+ public Point3D PlacementOrigin { get; }
+
+ public double PlacementRadius { get; }
+
+ public double AxialParameterFromPoint(Point3D point)
+ {
+ var offset = PlacementRadius / double.Tan(SemiAngleRadians);
+ return (point - PlacementOrigin).Dot(Axis.ToVector()) + offset;
+ }
+
public Point3D Evaluate(double u, double v)
{
var radialMagnitude = v * double.Tan(SemiAngleRadians);
@@ -59,4 +83,28 @@ public readonly record struct ConeSurface
var outward = radial - (Axis.ToVector() * double.Tan(SemiAngleRadians));
return Direction3D.Create(outward);
}
+
+ private static Direction3D ResolveXAxis(Direction3D axis, Direction3D referenceAxis)
+ {
+ var axisVector = axis.ToVector();
+ var reference = referenceAxis.ToVector();
+ var projected = reference - (axisVector * reference.Dot(axisVector));
+
+ if (!Direction3D.TryCreate(projected, out var xAxis))
+ {
+ throw new ArgumentOutOfRangeException(nameof(referenceAxis), "Reference axis must not be parallel to cone axis.");
+ }
+
+ return xAxis;
+ }
+
+ private static Direction3D ResolveYAxis(Direction3D axis, Direction3D xAxis)
+ {
+ if (!Direction3D.TryCreate(axis.ToVector().Cross(xAxis.ToVector()), out var yAxis))
+ {
+ throw new ArgumentOutOfRangeException(nameof(axis), "Axis must define a valid cone frame.");
+ }
+
+ return yAxis;
+ }
}
diff --git a/Aetheris.Kernel.Core/Step242/Step242Exporter.cs b/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
index 42ff2b3e..e566fb0f 100644
--- a/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242Exporter.cs
@@ -157,8 +157,8 @@ public static class Step242Exporter
private static string BuildCone(Step242TextWriter writer, ConeSurface cone)
{
- var axisPlacementId = BuildAxisPlacement(writer, cone.Apex, cone.Axis, BuildPerpendicularReferenceAxis(cone.Axis));
- return writer.AddEntity("CONICAL_SURFACE", "$", Step242TextWriter.Ref(axisPlacementId), Step242TextWriter.Number(0d), Step242TextWriter.Number(cone.SemiAngleRadians));
+ var axisPlacementId = BuildAxisPlacement(writer, cone.PlacementOrigin, cone.Axis, cone.ReferenceAxis);
+ return writer.AddEntity("CONICAL_SURFACE", "$", Step242TextWriter.Ref(axisPlacementId), Step242TextWriter.Number(cone.PlacementRadius), Step242TextWriter.Number(cone.SemiAngleRadians));
}
private static string BuildSphere(Step242TextWriter writer, SphereSurface sphere)
@@ -229,13 +229,6 @@ public static class Step242Exporter
return writer.AddEntity("AXIS2_PLACEMENT_3D", "$", Step242TextWriter.Ref(originId), Step242TextWriter.Ref(axisId), Step242TextWriter.Ref(referenceId));
}
- private static Direction3D BuildPerpendicularReferenceAxis(Direction3D axis)
- {
- var axisVector = axis.ToVector();
- var reference = double.Abs(axisVector.Dot(new Vector3D(1d, 0d, 0d))) <= 0.9d ? new Vector3D(1d, 0d, 0d) : new Vector3D(0d, 1d, 0d);
- var projected = reference - (axisVector * reference.Dot(axisVector));
- return Direction3D.Create(projected);
- }
private static KernelResult<string> BuildEdgeCurve(
BrepBody body,
TopologyModel model,
diff --git a/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs b/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs
index 2062576f..19d69742 100644
--- a/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs
@@ -245,75 +245,15 @@ internal static class Step242SubsetDecoder
public static KernelResult<PlaneSurface> ReadPlaneSurface(Step242ParsedDocument document, Step242ParsedEntity planeEntity)
{
- var placementRefResult = ReadReference(planeEntity, 1, "PLANE position");
- if (!placementRefResult.IsSuccess)
- {
- return KernelResult<PlaneSurface>.Failure(placementRefResult.Diagnostics);
- }
-
- var placementEntityResult = document.TryGetEntity(placementRefResult.Value.TargetId, "AXIS2_PLACEMENT_3D");
- if (!placementEntityResult.IsSuccess)
- {
- return KernelResult<PlaneSurface>.Failure(placementEntityResult.Diagnostics);
- }
-
- var originRefResult = ReadReference(placementEntityResult.Value, 1, "AXIS2_PLACEMENT_3D origin");
- if (!originRefResult.IsSuccess)
- {
- return KernelResult<PlaneSurface>.Failure(originRefResult.Diagnostics);
- }
-
- var originEntityResult = document.TryGetEntity(originRefResult.Value.TargetId, "CARTESIAN_POINT");
- if (!originEntityResult.IsSuccess)
- {
- return KernelResult<PlaneSurface>.Failure(originEntityResult.Diagnostics);
- }
-
- var originResult = ReadCartesianPoint(originEntityResult.Value, "AXIS2_PLACEMENT_3D origin");
- if (!originResult.IsSuccess)
- {
- return KernelResult<PlaneSurface>.Failure(originResult.Diagnostics);
- }
-
- var normalRefResult = ReadReference(placementEntityResult.Value, 2, "AXIS2_PLACEMENT_3D axis");
- if (!normalRefResult.IsSuccess)
- {
- return KernelResult<PlaneSurface>.Failure(normalRefResult.Diagnostics);
- }
-
- var normalEntityResult = document.TryGetEntity(normalRefResult.Value.TargetId, "DIRECTION");
- if (!normalEntityResult.IsSuccess)
- {
- return KernelResult<PlaneSurface>.Failure(normalEntityResult.Diagnostics);
- }
-
- var normalResult = ReadDirection(normalEntityResult.Value, "AXIS2_PLACEMENT_3D axis");
- if (!normalResult.IsSuccess)
- {
- return KernelResult<PlaneSurface>.Failure(normalResult.Diagnostics);
- }
-
- var refDirRefResult = ReadReference(placementEntityResult.Value, 3, "AXIS2_PLACEMENT_3D ref direction");
- if (!refDirRefResult.IsSuccess)
- {
- return KernelResult<PlaneSurface>.Failure(refDirRefResult.Diagnostics);
- }
-
- var refDirEntityResult = document.TryGetEntity(refDirRefResult.Value.TargetId, "DIRECTION");
- if (!refDirEntityResult.IsSuccess)
- {
- return KernelResult<PlaneSurface>.Failure(refDirEntityResult.Diagnostics);
- }
-
- var refDirResult = ReadDirection(refDirEntityResult.Value, "AXIS2_PLACEMENT_3D ref direction");
- if (!refDirResult.IsSuccess)
+ var placementResult = ReadAxis2Placement3D(document, planeEntity, 1, "PLANE position", SourceFor(planeEntity.Id, "Importer.Geometry.Plane"));
+ if (!placementResult.IsSuccess)
{
- return KernelResult<PlaneSurface>.Failure(refDirResult.Diagnostics);
+ return KernelResult<PlaneSurface>.Failure(placementResult.Diagnostics);
}
try
{
- return KernelResult<PlaneSurface>.Success(new PlaneSurface(originResult.Value, normalResult.Value, refDirResult.Value));
+ return KernelResult<PlaneSurface>.Success(new PlaneSurface(placementResult.Value.Origin, placementResult.Value.Axis, placementResult.Value.ReferenceAxis));
}
catch (ArgumentException)
{
@@ -658,12 +598,9 @@ internal static class Step242SubsetDecoder
}
var normalizedSemiAngle = normalizedSemiAngleResult.Value;
- var offset = placementResult.Value.Axis.ToVector() * (radiusResult.Value / double.Tan(normalizedSemiAngle));
- var apex = placementResult.Value.Origin - offset;
-
try
{
- return KernelResult<ConeSurface>.Success(new ConeSurface(apex, placementResult.Value.Axis, normalizedSemiAngle, placementResult.Value.ReferenceAxis));
+ return KernelResult<ConeSurface>.Success(new ConeSurface(placementResult.Value.Origin, placementResult.Value.Axis, radiusResult.Value, normalizedSemiAngle, placementResult.Value.ReferenceAxis));
}
catch (ArgumentException)
{
@@ -726,48 +663,50 @@ internal static class Step242SubsetDecoder
return KernelResult<(Point3D, Direction3D, Direction3D)>.Failure(originResult.Diagnostics);
}
- var axisRefResult = ReadReference(placementEntity, 2, "AXIS2_PLACEMENT_3D axis");
- if (!axisRefResult.IsSuccess)
+ var axisResult = ReadPlacementDirection(document, placementEntity, 2, "AXIS2_PLACEMENT_3D axis", new Vector3D(0d, 0d, 1d));
+ if (!axisResult.IsSuccess)
{
- return KernelResult<(Point3D, Direction3D, Direction3D)>.Failure(axisRefResult.Diagnostics);
+ return KernelResult<(Point3D, Direction3D, Direction3D)>.Failure(axisResult.Diagnostics);
}
- var axisEntityResult = document.TryGetEntity(axisRefResult.Value.TargetId, "DIRECTION");
- if (!axisEntityResult.IsSuccess)
+ var refDirResult = ReadPlacementDirection(document, placementEntity, 3, "AXIS2_PLACEMENT_3D ref direction", new Vector3D(1d, 0d, 0d));
+ if (!refDirResult.IsSuccess)
{
- return KernelResult<(Point3D, Direction3D, Direction3D)>.Failure(axisEntityResult.Diagnostics);
+ return KernelResult<(Point3D, Direction3D, Direction3D)>.Failure(refDirResult.Diagnostics);
}
- var axisResult = ReadDirection(axisEntityResult.Value, "AXIS2_PLACEMENT_3D axis");
- if (!axisResult.IsSuccess)
+ if (double.Abs(axisResult.Value.ToVector().Dot(refDirResult.Value.ToVector())) >= 1d - 1e-12d)
{
- return KernelResult<(Point3D, Direction3D, Direction3D)>.Failure(axisResult.Diagnostics);
+ return FailureAxisPlacement("AXIS2_PLACEMENT_3D axis and ref direction must not be parallel.", geometrySource);
}
- var refDirRefResult = ReadReference(placementEntity, 3, "AXIS2_PLACEMENT_3D ref direction");
- if (!refDirRefResult.IsSuccess)
+ return KernelResult<(Point3D, Direction3D, Direction3D)>.Success((originResult.Value, axisResult.Value, refDirResult.Value));
+ }
+
+ private static KernelResult<Direction3D> ReadPlacementDirection(Step242ParsedDocument document, Step242ParsedEntity placementEntity, int argumentIndex, string context, Vector3D defaultDirection)
+ {
+ if (argumentIndex < 0 || argumentIndex >= placementEntity.Arguments.Count)
{
- return KernelResult<(Point3D, Direction3D, Direction3D)>.Failure(refDirRefResult.Diagnostics);
+ return FailureDirection($"{context}: missing argument at index {argumentIndex}.", $"Entity:{placementEntity.Id}");
}
- var refDirEntityResult = document.TryGetEntity(refDirRefResult.Value.TargetId, "DIRECTION");
- if (!refDirEntityResult.IsSuccess)
+ if (placementEntity.Arguments[argumentIndex] is Step242OmittedValue)
{
- return KernelResult<(Point3D, Direction3D, Direction3D)>.Failure(refDirEntityResult.Diagnostics);
+ return KernelResult<Direction3D>.Success(Direction3D.Create(defaultDirection));
}
- var refDirResult = ReadDirection(refDirEntityResult.Value, "AXIS2_PLACEMENT_3D ref direction");
- if (!refDirResult.IsSuccess)
+ if (placementEntity.Arguments[argumentIndex] is not Step242EntityReference reference)
{
- return KernelResult<(Point3D, Direction3D, Direction3D)>.Failure(refDirResult.Diagnostics);
+ return FailureDirection($"{context}: expected entity reference argument.", $"Entity:{placementEntity.Id}");
}
- if (double.Abs(axisResult.Value.ToVector().Dot(refDirResult.Value.ToVector())) >= 1d - 1e-12d)
+ var directionEntityResult = document.TryGetEntity(reference.TargetId, "DIRECTION");
+ if (!directionEntityResult.IsSuccess)
{
- return FailureAxisPlacement("AXIS2_PLACEMENT_3D axis and ref direction must not be parallel.", geometrySource);
+ return KernelResult<Direction3D>.Failure(directionEntityResult.Diagnostics);
}
- return KernelResult<(Point3D, Direction3D, Direction3D)>.Success((originResult.Value, axisResult.Value, refDirResult.Value));
+ return ReadDirection(directionEntityResult.Value, context);
}
private static KernelResult<double> ReadNumberArgument(Step242ParsedEntity entity, int argumentIndex, string context, string source)