Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add AP242 B_SPLINE_CURVE_WITH_KNOTS edge curve support

Yuechen Lic6121833b162
diff --git a/Aetheris.Kernel.Core.Tests/Step242/Step242BSplineEdgeTests.cs b/Aetheris.Kernel.Core.Tests/Step242/Step242BSplineEdgeTests.cs
new file mode 100644
index 00000000..a4f81d23
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Step242/Step242BSplineEdgeTests.cs
@@ -0,0 +1,84 @@
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Step242;
+
+namespace Aetheris.Kernel.Core.Tests.Step242;
+
+public sealed class Step242BSplineEdgeTests
+{
+ [Fact]
+ public void Step242_BSplineCurveWithKnots_AsEdgeCurve_ImportsAndSamplesDeterministically()
+ {
+ 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),#30,.T.);\n"
+ + "#4=FACE_OUTER_BOUND($,#5,.T.);\n"
+ + "#5=EDGE_LOOP($,(#6,#7,#8));\n"
+ + "#6=ORIENTED_EDGE($,$,$,#9,.T.);\n"
+ + "#7=ORIENTED_EDGE($,$,$,#10,.T.);\n"
+ + "#8=ORIENTED_EDGE($,$,$,#11,.T.);\n"
+ + "#9=EDGE_CURVE($,#12,#13,#20,.T.);\n"
+ + "#10=EDGE_CURVE($,#13,#14,#21,.T.);\n"
+ + "#11=EDGE_CURVE($,#14,#12,#22,.T.);\n"
+ + "#12=VERTEX_POINT($,#40);\n"
+ + "#13=VERTEX_POINT($,#41);\n"
+ + "#14=VERTEX_POINT($,#42);\n"
+ + "#20=B_SPLINE_CURVE_WITH_KNOTS($,2,(#40,#43,#41),.UNSPECIFIED.,.F.,.F.,(3,3),(0.,1.),.UNSPECIFIED.);\n"
+ + "#21=LINE($,#41,#50);\n"
+ + "#22=LINE($,#42,#51);\n"
+ + "#30=PLANE($,#60);\n"
+ + "#40=CARTESIAN_POINT($,(0.,0.,0.));\n"
+ + "#41=CARTESIAN_POINT($,(2.,0.,0.));\n"
+ + "#42=CARTESIAN_POINT($,(0.,2.,0.));\n"
+ + "#43=CARTESIAN_POINT($,(1.,0.6,0.));\n"
+ + "#50=VECTOR($,#52,1.);\n"
+ + "#51=VECTOR($,#53,1.);\n"
+ + "#52=DIRECTION($,(-0.7071067811865475,0.7071067811865475,0.));\n"
+ + "#53=DIRECTION($,(0.,-1.,0.));\n"
+ + "#60=AXIS2_PLACEMENT_3D($,#40,#61,#62);\n"
+ + "#61=DIRECTION($,(0.,0.,1.));\n"
+ + "#62=DIRECTION($,(1.,0.,0.));\n"
+ + "ENDSEC;\nEND-ISO-10303-21;";
+
+ var first = Step242Importer.ImportBody(text);
+ Assert.True(first.IsSuccess);
+
+ var second = Step242Importer.ImportBody(text);
+ Assert.True(second.IsSuccess);
+
+ var curveA = Assert.Single(first.Value.Geometry.Curves, c => c.Value.Kind == CurveGeometryKind.BSpline3).Value.BSpline3;
+ var curveB = Assert.Single(second.Value.Geometry.Curves, c => c.Value.Kind == CurveGeometryKind.BSpline3).Value.BSpline3;
+ Assert.NotNull(curveA);
+ Assert.NotNull(curveB);
+ Assert.Equal(2, curveA.Value.Degree);
+ Assert.Equal(0d, curveA.Value.DomainStart);
+ Assert.Equal(1d, curveA.Value.DomainEnd);
+
+ var parameters = new[] { 0d, 0.2d, 0.4d, 0.6d, 0.8d, 1d };
+ var samplesA = parameters.Select(curveA.Value.Evaluate).ToArray();
+ var samplesB = parameters.Select(curveB.Value.Evaluate).ToArray();
+ Assert.True(samplesA.SequenceEqual(samplesB));
+ }
+
+ [Theory]
+ [InlineData("testdata/step242/nist/CTC/nist_ctc_01_asme1_ap242-e1.stp")]
+ [InlineData("testdata/step242/nist/FTC/nist_ftc_07_asme1_ap242-e2.stp")]
+ [InlineData("testdata/step242/nist/FTC/nist_ftc_09_asme1_ap242-e1.stp")]
+ [InlineData("testdata/step242/nist/FTC/nist_ftc_11_asme1_ap242-e2.stp")]
+ public void Step242_NistTargets_AdvancePastBsplineEdgeUnsupportedBlocker(string relativePath)
+ {
+ var entry = new Step242CorpusManifestEntry(
+ Id: Path.GetFileNameWithoutExtension(relativePath),
+ Path: relativePath,
+ Group: "nist-bspline-regression",
+ Notes: "regression",
+ ExpectedFirstDiagnostic: null,
+ ExpectHashStableAfterCanonicalization: null,
+ ExpectTopologyCounts: null,
+ ExpectGeometryKinds: null);
+
+ var report = Step242CorpusManifestRunner.RunOne(entry);
+
+ Assert.NotEqual("EDGE_CURVE geometry 'B_SPLINE_CURVE_WITH_KNOTS' is unsupported.", report.FirstDiagnostic.MessagePrefix);
+ }
+}
diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs
index f8bfc23f..323befd9 100644
--- a/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs
+++ b/Aetheris.Kernel.Core/Brep/Tessellation/BrepDisplayTessellator.cs
@@ -1133,6 +1133,13 @@ public static class BrepDisplayTessellator
return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(edgeId, points, isClosed));
+ case CurveGeometryKind.BSpline3:
+ var spline = curve.BSpline3!.Value;
+ return KernelResult<DisplayEdgePolyline>.Success(new DisplayEdgePolyline(
+ edgeId,
+ CurveSampler.SampleBSpline(spline, interval),
+ IsClosed: false));
+
default:
return KernelResult<DisplayEdgePolyline>.Failure([CreateNotImplemented($"Edge {edgeId.Value} has unsupported curve kind '{curve.Kind}'.")]);
}
@@ -1218,6 +1225,7 @@ public static class BrepDisplayTessellator
{
CurveGeometryKind.Line3 => KernelResult<Point3D>.Success(curve.Line3!.Value.Evaluate(parameter)),
CurveGeometryKind.Circle3 => KernelResult<Point3D>.Success(curve.Circle3!.Value.Evaluate(parameter)),
+ CurveGeometryKind.BSpline3 => KernelResult<Point3D>.Success(curve.BSpline3!.Value.Evaluate(parameter)),
_ => KernelResult<Point3D>.Failure([CreateNotImplemented($"Edge {edgeId.Value} endpoint evaluation does not support curve kind '{curve.UnsupportedKind ?? curve.Kind.ToString()}'.", PlanarCurveFlatteningUnsupportedSource)]),
};
}
diff --git a/Aetheris.Kernel.Core/Brep/Tessellation/CurveSampler.cs b/Aetheris.Kernel.Core/Brep/Tessellation/CurveSampler.cs
index 70de4888..6f848250 100644
--- a/Aetheris.Kernel.Core/Brep/Tessellation/CurveSampler.cs
+++ b/Aetheris.Kernel.Core/Brep/Tessellation/CurveSampler.cs
@@ -26,6 +26,25 @@ internal static class CurveSampler
return points;
}
+
+ public static IReadOnlyList<Point3D> SampleBSpline(BSpline3Curve spline, ParameterInterval interval)
+ {
+ var minSegments = 8;
+ var maxSegments = 128;
+ var controlDriven = spline.ControlPoints.Count * 2;
+ var segmentCount = System.Math.Clamp(controlDriven, minSegments, maxSegments);
+
+ var points = new List<Point3D>(segmentCount + 1);
+ var span = interval.End - interval.Start;
+ for (var i = 0; i <= segmentCount; i++)
+ {
+ var t = (double)i / segmentCount;
+ points.Add(spline.Evaluate(interval.Start + (span * t)));
+ }
+
+ return points;
+ }
+
public static bool TrySampleTrimmedCircleArc(
Circle3Curve circle,
Point3D startPoint,
diff --git a/Aetheris.Kernel.Core/Geometry/CurveGeometry.cs b/Aetheris.Kernel.Core/Geometry/CurveGeometry.cs
index e62b39e5..a4651e89 100644
--- a/Aetheris.Kernel.Core/Geometry/CurveGeometry.cs
+++ b/Aetheris.Kernel.Core/Geometry/CurveGeometry.cs
@@ -6,6 +6,7 @@ public enum CurveGeometryKind
{
Line3,
Circle3,
+ BSpline3,
Unsupported,
}
@@ -14,11 +15,12 @@ public enum CurveGeometryKind
/// </summary>
public sealed record CurveGeometry
{
- private CurveGeometry(CurveGeometryKind kind, Line3Curve? line3, Circle3Curve? circle3, string? unsupportedKind)
+ private CurveGeometry(CurveGeometryKind kind, Line3Curve? line3, Circle3Curve? circle3, BSpline3Curve? bSpline3, string? unsupportedKind)
{
Kind = kind;
Line3 = line3;
Circle3 = circle3;
+ BSpline3 = bSpline3;
UnsupportedKind = unsupportedKind;
}
@@ -28,11 +30,15 @@ public sealed record CurveGeometry
public Circle3Curve? Circle3 { get; }
+ public BSpline3Curve? BSpline3 { get; }
+
public string? UnsupportedKind { get; }
- public static CurveGeometry FromLine(Line3Curve line) => new(CurveGeometryKind.Line3, line, null, null);
+ public static CurveGeometry FromLine(Line3Curve line) => new(CurveGeometryKind.Line3, line, null, null, null);
+
+ public static CurveGeometry FromCircle(Circle3Curve circle) => new(CurveGeometryKind.Circle3, null, circle, null, null);
- public static CurveGeometry FromCircle(Circle3Curve circle) => new(CurveGeometryKind.Circle3, null, circle, null);
+ public static CurveGeometry FromBSpline(BSpline3Curve curve) => new(CurveGeometryKind.BSpline3, null, null, curve, null);
- public static CurveGeometry FromUnsupported(string kindName) => new(CurveGeometryKind.Unsupported, null, null, kindName);
+ public static CurveGeometry FromUnsupported(string kindName) => new(CurveGeometryKind.Unsupported, null, null, null, kindName);
}
diff --git a/Aetheris.Kernel.Core/Geometry/Curves/BSpline3Curve.cs b/Aetheris.Kernel.Core/Geometry/Curves/BSpline3Curve.cs
new file mode 100644
index 00000000..61b980cf
--- /dev/null
+++ b/Aetheris.Kernel.Core/Geometry/Curves/BSpline3Curve.cs
@@ -0,0 +1,194 @@
+using Aetheris.Kernel.Core.Math;
+
+namespace Aetheris.Kernel.Core.Geometry.Curves;
+
+public readonly record struct BSpline3Curve
+{
+ public BSpline3Curve(
+ int degree,
+ IReadOnlyList<Point3D> controlPoints,
+ IReadOnlyList<int> knotMultiplicities,
+ IReadOnlyList<double> knotValues,
+ string curveForm,
+ bool closedCurve,
+ bool selfIntersect,
+ string knotSpec)
+ {
+ if (degree < 1)
+ {
+ throw new ArgumentOutOfRangeException(nameof(degree), "Degree must be greater than or equal to one.");
+ }
+
+ if (controlPoints is null || controlPoints.Count < degree + 1)
+ {
+ throw new ArgumentException("Control point count must be at least degree + 1.", nameof(controlPoints));
+ }
+
+ if (knotMultiplicities is null || knotValues is null || knotMultiplicities.Count == 0 || knotMultiplicities.Count != knotValues.Count)
+ {
+ throw new ArgumentException("Knot multiplicities and values must be non-empty and have matching counts.");
+ }
+
+ var fullKnots = ExpandKnots(knotMultiplicities, knotValues);
+ var expectedKnotCount = controlPoints.Count + degree + 1;
+ if (fullKnots.Count != expectedKnotCount)
+ {
+ throw new ArgumentException($"Expanded knot count must be {expectedKnotCount} for degree {degree} and {controlPoints.Count} control points.");
+ }
+
+ for (var i = 1; i < fullKnots.Count; i++)
+ {
+ if (fullKnots[i] < fullKnots[i - 1])
+ {
+ throw new ArgumentException("Expanded knot vector must be non-decreasing.");
+ }
+ }
+
+ Degree = degree;
+ ControlPoints = controlPoints.ToArray();
+ KnotMultiplicities = knotMultiplicities.ToArray();
+ KnotValues = knotValues.ToArray();
+ FullKnots = fullKnots;
+ CurveForm = curveForm;
+ ClosedCurve = closedCurve;
+ SelfIntersect = selfIntersect;
+ KnotSpec = knotSpec;
+
+ DomainStart = FullKnots[Degree];
+ DomainEnd = FullKnots[FullKnots.Count - Degree - 1];
+ if (DomainEnd < DomainStart)
+ {
+ throw new ArgumentException("Computed knot domain is invalid.");
+ }
+ }
+
+ public int Degree { get; }
+
+ public IReadOnlyList<Point3D> ControlPoints { get; }
+
+ public IReadOnlyList<int> KnotMultiplicities { get; }
+
+ public IReadOnlyList<double> KnotValues { get; }
+
+ public IReadOnlyList<double> FullKnots { get; }
+
+ public string CurveForm { get; }
+
+ public bool ClosedCurve { get; }
+
+ public bool SelfIntersect { get; }
+
+ public string KnotSpec { get; }
+
+ public double DomainStart { get; }
+
+ public double DomainEnd { get; }
+
+ public Point3D Evaluate(double parameter)
+ {
+ if (!double.IsFinite(parameter))
+ {
+ throw new ArgumentOutOfRangeException(nameof(parameter), "Parameter must be finite.");
+ }
+
+ var p = Degree;
+ var u = ClampToDomain(parameter);
+
+ if (double.Abs(u - DomainEnd) <= 1e-12d)
+ {
+ return ControlPoints[^1];
+ }
+
+ var span = FindSpan(u);
+ var d = new Point3D[p + 1];
+ for (var j = 0; j <= p; j++)
+ {
+ d[j] = ControlPoints[span - p + j];
+ }
+
+ for (var r = 1; r <= p; r++)
+ {
+ for (var j = p; j >= r; j--)
+ {
+ var leftKnot = FullKnots[span - p + j];
+ var rightKnot = FullKnots[span + 1 + j - r];
+ var denominator = rightKnot - leftKnot;
+ var alpha = double.Abs(denominator) <= 1e-15d ? 0d : (u - leftKnot) / denominator;
+ d[j] = Lerp(d[j - 1], d[j], alpha);
+ }
+ }
+
+ return d[p];
+ }
+
+ private double ClampToDomain(double parameter)
+ {
+ if (parameter <= DomainStart)
+ {
+ return DomainStart;
+ }
+
+ if (parameter >= DomainEnd)
+ {
+ return DomainEnd;
+ }
+
+ return parameter;
+ }
+
+ private int FindSpan(double u)
+ {
+ var n = ControlPoints.Count - 1;
+ if (u >= FullKnots[n + 1])
+ {
+ return n;
+ }
+
+ var low = Degree;
+ var high = n + 1;
+ var mid = (low + high) / 2;
+ while (u < FullKnots[mid] || u >= FullKnots[mid + 1])
+ {
+ if (u < FullKnots[mid])
+ {
+ high = mid;
+ }
+ else
+ {
+ low = mid;
+ }
+
+ mid = (low + high) / 2;
+ }
+
+ return mid;
+ }
+
+ private static IReadOnlyList<double> ExpandKnots(IReadOnlyList<int> multiplicities, IReadOnlyList<double> values)
+ {
+ var knots = new List<double>();
+ for (var i = 0; i < multiplicities.Count; i++)
+ {
+ var multiplicity = multiplicities[i];
+ var value = values[i];
+ if (multiplicity <= 0 || !double.IsFinite(value))
+ {
+ throw new ArgumentException("Knot multiplicities must be positive and knot values must be finite.");
+ }
+
+ for (var k = 0; k < multiplicity; k++)
+ {
+ knots.Add(value);
+ }
+ }
+
+ return knots;
+ }
+
+ private static Point3D Lerp(Point3D left, Point3D right, double alpha)
+ {
+ var clamped = System.Math.Clamp(alpha, 0d, 1d);
+ var delta = right - left;
+ return left + (delta * clamped);
+ }
+}
diff --git a/Aetheris.Kernel.Core/Step242/Step242Importer.cs b/Aetheris.Kernel.Core/Step242/Step242Importer.cs
index a95f1aef..39018bf1 100644
--- a/Aetheris.Kernel.Core/Step242/Step242Importer.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242Importer.cs
@@ -516,6 +516,19 @@ public static class Step242Importer
trimResult.Value));
}
+ if (string.Equals(curveEntity.Name, "B_SPLINE_CURVE_WITH_KNOTS", StringComparison.OrdinalIgnoreCase))
+ {
+ var splineResult = Step242SubsetDecoder.ReadBSplineCurveWithKnots(document, curveEntity);
+ if (!splineResult.IsSuccess)
+ {
+ return KernelResult<(CurveGeometry CurveGeometry, ParameterInterval TrimInterval)>.Failure(splineResult.Diagnostics);
+ }
+
+ return KernelResult<(CurveGeometry CurveGeometry, ParameterInterval TrimInterval)>.Success((
+ CurveGeometry.FromBSpline(splineResult.Value),
+ new ParameterInterval(splineResult.Value.DomainStart, splineResult.Value.DomainEnd)));
+ }
+
if (string.Equals(curveEntity.Name, "AETHERIS_PLANAR_UNSUPPORTED_CURVE", StringComparison.OrdinalIgnoreCase))
{
return KernelResult<(CurveGeometry CurveGeometry, ParameterInterval TrimInterval)>.Success((
@@ -1188,6 +1201,12 @@ public static class Step242Importer
var mid = trim.Start + ((trim.End - trim.Start) * 0.5d);
points = [circle.Evaluate(trim.Start), circle.Evaluate(mid), circle.Evaluate(trim.End)];
break;
+ case CurveGeometryKind.BSpline3:
+ var spline = curve.BSpline3!.Value;
+ var splineTrim = edgeBinding.TrimInterval ?? new ParameterInterval(spline.DomainStart, spline.DomainEnd);
+ var splineMid = splineTrim.Start + ((splineTrim.End - splineTrim.Start) * 0.5d);
+ points = [spline.Evaluate(splineTrim.Start), spline.Evaluate(splineMid), spline.Evaluate(splineTrim.End)];
+ break;
default:
points = [];
break;
diff --git a/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs b/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs
index c5326c43..bc716f07 100644
--- a/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs
+++ b/Aetheris.Kernel.Core/Step242/Step242SubsetDecoder.cs
@@ -353,6 +353,75 @@ internal static class Step242SubsetDecoder
}
}
+
+ public static KernelResult<BSpline3Curve> ReadBSplineCurveWithKnots(Step242ParsedDocument document, Step242ParsedEntity splineEntity)
+ {
+ var degreeResult = ReadIntArgument(splineEntity, 1, "B_SPLINE_CURVE_WITH_KNOTS degree", "Importer.Geometry.BSplineCurve");
+ if (!degreeResult.IsSuccess)
+ {
+ return KernelResult<BSpline3Curve>.Failure(degreeResult.Diagnostics);
+ }
+
+ var controlPointsResult = ReadCartesianPointReferenceList(document, splineEntity, 2, "B_SPLINE_CURVE_WITH_KNOTS control_points_list");
+ if (!controlPointsResult.IsSuccess)
+ {
+ return KernelResult<BSpline3Curve>.Failure(controlPointsResult.Diagnostics);
+ }
+
+ var curveFormResult = ReadEnumArgument(splineEntity, 3, "B_SPLINE_CURVE_WITH_KNOTS curve_form", "Importer.Geometry.BSplineCurve");
+ if (!curveFormResult.IsSuccess)
+ {
+ return KernelResult<BSpline3Curve>.Failure(curveFormResult.Diagnostics);
+ }
+
+ var closedCurveResult = ReadBoolean(splineEntity, 4, "B_SPLINE_CURVE_WITH_KNOTS closed_curve");
+ if (!closedCurveResult.IsSuccess)
+ {
+ return KernelResult<BSpline3Curve>.Failure(closedCurveResult.Diagnostics);
+ }
+
+ var selfIntersectResult = ReadBoolean(splineEntity, 5, "B_SPLINE_CURVE_WITH_KNOTS self_intersect");
+ if (!selfIntersectResult.IsSuccess)
+ {
+ return KernelResult<BSpline3Curve>.Failure(selfIntersectResult.Diagnostics);
+ }
+
+ var multiplicitiesResult = ReadIntegerListArgument(splineEntity, 6, "B_SPLINE_CURVE_WITH_KNOTS knot_multiplicities", "Importer.Geometry.BSplineCurve");
+ if (!multiplicitiesResult.IsSuccess)
+ {
+ return KernelResult<BSpline3Curve>.Failure(multiplicitiesResult.Diagnostics);
+ }
+
+ var knotValuesResult = ReadNumberListArgument(splineEntity, 7, "B_SPLINE_CURVE_WITH_KNOTS knots", "Importer.Geometry.BSplineCurve");
+ if (!knotValuesResult.IsSuccess)
+ {
+ return KernelResult<BSpline3Curve>.Failure(knotValuesResult.Diagnostics);
+ }
+
+ var knotSpecResult = ReadEnumArgument(splineEntity, 8, "B_SPLINE_CURVE_WITH_KNOTS knot_spec", "Importer.Geometry.BSplineCurve");
+ if (!knotSpecResult.IsSuccess)
+ {
+ return KernelResult<BSpline3Curve>.Failure(knotSpecResult.Diagnostics);
+ }
+
+ try
+ {
+ return KernelResult<BSpline3Curve>.Success(new BSpline3Curve(
+ degreeResult.Value,
+ controlPointsResult.Value,
+ multiplicitiesResult.Value,
+ knotValuesResult.Value,
+ curveFormResult.Value,
+ closedCurveResult.Value,
+ selfIntersectResult.Value,
+ knotSpecResult.Value));
+ }
+ catch (ArgumentException ex)
+ {
+ return FailureBSplineCurve(ex.Message, "Importer.Geometry.BSplineCurve");
+ }
+ }
+
public static KernelResult<CylinderSurface> ReadCylindricalSurface(Step242ParsedDocument document, Step242ParsedEntity cylinderEntity)
{
var placementResult = ReadAxis2Placement3D(document, cylinderEntity, 1, "CYLINDRICAL_SURFACE position", "Importer.Geometry.Cylinder");
@@ -641,6 +710,155 @@ internal static class Step242SubsetDecoder
return KernelResult<double>.Success(number.Value);
}
+ private static KernelResult<IReadOnlyList<Point3D>> ReadCartesianPointReferenceList(
+ Step242ParsedDocument document,
+ Step242ParsedEntity ownerEntity,
+ int argumentIndex,
+ string context)
+ {
+ if (argumentIndex < 0 || argumentIndex >= ownerEntity.Arguments.Count)
+ {
+ return Failure<IReadOnlyList<Point3D>>(KernelDiagnosticCode.InvalidArgument, $"{context}: missing argument at index {argumentIndex}.", "Importer.Geometry.BSplineCurve");
+ }
+
+ if (ownerEntity.Arguments[argumentIndex] is not Step242ListValue list)
+ {
+ return Failure<IReadOnlyList<Point3D>>(KernelDiagnosticCode.InvalidArgument, $"{context}: expected aggregate list of CARTESIAN_POINT references.", "Importer.Geometry.BSplineCurve");
+ }
+
+ var points = new List<Point3D>(list.Items.Count);
+ for (var i = 0; i < list.Items.Count; i++)
+ {
+ if (list.Items[i] is not Step242EntityReference pointReference)
+ {
+ return Failure<IReadOnlyList<Point3D>>(KernelDiagnosticCode.InvalidArgument, $"{context}: item {i} must be an entity reference (#id).", "Importer.Geometry.BSplineCurve");
+ }
+
+ var pointEntityResult = document.TryGetEntity(pointReference.TargetId, "CARTESIAN_POINT");
+ if (!pointEntityResult.IsSuccess)
+ {
+ return KernelResult<IReadOnlyList<Point3D>>.Failure(pointEntityResult.Diagnostics);
+ }
+
+ var pointResult = ReadCartesianPoint(pointEntityResult.Value, context);
+ if (!pointResult.IsSuccess)
+ {
+ return KernelResult<IReadOnlyList<Point3D>>.Failure(pointResult.Diagnostics);
+ }
+
+ points.Add(pointResult.Value);
+ }
+
+ return KernelResult<IReadOnlyList<Point3D>>.Success(points);
+ }
+
+ private static KernelResult<IReadOnlyList<int>> ReadIntegerListArgument(
+ Step242ParsedEntity entity,
+ int argumentIndex,
+ string context,
+ string source)
+ {
+ var numbersResult = ReadNumberListArgument(entity, argumentIndex, context, source);
+ if (!numbersResult.IsSuccess)
+ {
+ return KernelResult<IReadOnlyList<int>>.Failure(numbersResult.Diagnostics);
+ }
+
+ var ints = new List<int>(numbersResult.Value.Count);
+ for (var i = 0; i < numbersResult.Value.Count; i++)
+ {
+ var number = numbersResult.Value[i];
+ var rounded = System.Math.Round(number);
+ if (double.Abs(number - rounded) > 1e-9d)
+ {
+ return Failure<IReadOnlyList<int>>(KernelDiagnosticCode.InvalidArgument, $"{context}: item {i} must be an integer value.", source);
+ }
+
+ if (rounded < int.MinValue || rounded > int.MaxValue)
+ {
+ return Failure<IReadOnlyList<int>>(KernelDiagnosticCode.InvalidArgument, $"{context}: item {i} is outside integer range.", source);
+ }
+
+ ints.Add((int)rounded);
+ }
+
+ return KernelResult<IReadOnlyList<int>>.Success(ints);
+ }
+
+ private static KernelResult<IReadOnlyList<double>> ReadNumberListArgument(
+ Step242ParsedEntity entity,
+ int argumentIndex,
+ string context,
+ string source)
+ {
+ if (argumentIndex < 0 || argumentIndex >= entity.Arguments.Count)
+ {
+ return Failure<IReadOnlyList<double>>(KernelDiagnosticCode.InvalidArgument, $"{context}: missing argument at index {argumentIndex}.", source);
+ }
+
+ if (entity.Arguments[argumentIndex] is not Step242ListValue list)
+ {
+ return Failure<IReadOnlyList<double>>(KernelDiagnosticCode.InvalidArgument, $"{context}: expected aggregate list.", source);
+ }
+
+ var values = new List<double>(list.Items.Count);
+ for (var i = 0; i < list.Items.Count; i++)
+ {
+ var valueResult = ReadNumberCode(list.Items[i], context, source);
+ if (!valueResult.IsSuccess)
+ {
+ return KernelResult<IReadOnlyList<double>>.Failure(valueResult.Diagnostics);
+ }
+
+ values.Add(valueResult.Value);
+ }
+
+ return KernelResult<IReadOnlyList<double>>.Success(values);
+ }
+
+ private static KernelResult<string> ReadEnumArgument(Step242ParsedEntity entity, int argumentIndex, string context, string source)
+ {
+ if (argumentIndex < 0 || argumentIndex >= entity.Arguments.Count)
+ {
+ return Failure<string>(KernelDiagnosticCode.InvalidArgument, $"{context}: missing argument at index {argumentIndex}.", source);
+ }
+
+ var unwrappedResult = UnwrapTypedValue(entity.Arguments[argumentIndex], context, source);
+ if (!unwrappedResult.IsSuccess)
+ {
+ return KernelResult<string>.Failure(unwrappedResult.Diagnostics);
+ }
+
+ if (unwrappedResult.Value is not Step242EnumValue enumValue)
+ {
+ return Failure<string>(KernelDiagnosticCode.InvalidArgument, $"{context}: expected enumeration value.", source);
+ }
+
+ return KernelResult<string>.Success(enumValue.Value);
+ }
+
+ private static KernelResult<int> ReadIntArgument(Step242ParsedEntity entity, int argumentIndex, string context, string source)
+ {
+ var valueResult = ReadNumberArgument(entity, argumentIndex, context, source);
+ if (!valueResult.IsSuccess)
+ {
+ return KernelResult<int>.Failure(valueResult.Diagnostics);
+ }
+
+ var rounded = System.Math.Round(valueResult.Value);
+ if (double.Abs(valueResult.Value - rounded) > 1e-9d)
+ {
+ return Failure<int>(KernelDiagnosticCode.InvalidArgument, $"{context}: expected integer value.", source);
+ }
+
+ if (rounded < int.MinValue || rounded > int.MaxValue)
+ {
+ return Failure<int>(KernelDiagnosticCode.InvalidArgument, $"{context}: value is outside integer range.", source);
+ }
+
+ return KernelResult<int>.Success((int)rounded);
+ }
+
private static KernelResult<Step242Value> UnwrapTypedValue(Step242Value value, string context, string source)
{
if (value is not Step242TypedValue typed)
@@ -703,6 +921,8 @@ internal static class Step242SubsetDecoder
private static KernelResult<Circle3Curve> FailureCircle(string message, string source) => Failure<Circle3Curve>(KernelDiagnosticCode.InvalidArgument, message, source);
+ private static KernelResult<BSpline3Curve> FailureBSplineCurve(string message, string source) => Failure<BSpline3Curve>(KernelDiagnosticCode.InvalidArgument, message, source);
+
private static KernelResult<CylinderSurface> FailureCylinder(string message, string source) => Failure<CylinderSurface>(KernelDiagnosticCode.InvalidArgument, message, source);
private static KernelResult<SphereSurface> FailureSphere(string message, string source) => Failure<SphereSurface>(KernelDiagnosticCode.InvalidArgument, message, source);