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.csnew file mode 100644index 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.csindex 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 BrepDisplayTessellatorreturn 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.csindex 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 CurveSamplerreturn 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.csindex 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 CurveGeometrypublic 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.csnew file mode 100644index 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.csindex a95f1aef..39018bf1 100644--- a/Aetheris.Kernel.Core/Step242/Step242Importer.cs+++ b/Aetheris.Kernel.Core/Step242/Step242Importer.cs@@ -516,6 +516,19 @@ public static class Step242ImportertrimResult.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 Step242Importervar 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.csindex 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 Step242SubsetDecoderreturn 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 Step242SubsetDecoderprivate 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);