Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add ASM-A3 firmasm execution and asm exec CLI
Yuechen Lib8f3698126b8
diff --git a/Aetheris.CLI.Tests/CliBaselineTests.cs b/Aetheris.CLI.Tests/CliBaselineTests.csindex a32bf8f3..3659e992 100644--- a/Aetheris.CLI.Tests/CliBaselineTests.cs+++ b/Aetheris.CLI.Tests/CliBaselineTests.cs@@ -31,6 +31,52 @@ public sealed class CliBaselineTestsFile.Delete(outputPath);}+ [Fact]+ public void Asm_Exec_Command_Executes_OcctNutBolt_And_Returns_Analysis()+ {+ var stdout = new StringWriter();+ var stderr = new StringWriter();+ var manifestPath = Path.Combine(RepoRoot, "testdata/firmasm/examples/occt-nut-bolt/nut-bolt-assembly.firmasm");++ var exitCode = Aetheris.CLI.CliRunner.Run(+ ["asm", "exec", manifestPath, "--json"],+ stdout,+ stderr);++ Assert.Equal(0, exitCode);+ Assert.True(string.IsNullOrWhiteSpace(stderr.ToString()));++ using var doc = JsonDocument.Parse(stdout.ToString());+ var root = doc.RootElement;+ Assert.True(root.GetProperty("success").GetBoolean());+ Assert.Equal(2, root.GetProperty("partCount").GetInt32());+ Assert.Equal(2, root.GetProperty("instanceCount").GetInt32());+ Assert.Equal(2, root.GetProperty("analysis").GetProperty("summary").GetProperty("bodyCount").GetInt32());+ }++ [Fact]+ public void Asm_Exec_Command_Executes_As1_Full_Assembly()+ {+ var stdout = new StringWriter();+ var stderr = new StringWriter();+ var manifestPath = Path.Combine(RepoRoot, "testdata/firmasm/examples/occt-as1/as1-assembly.firmasm");++ var exitCode = Aetheris.CLI.CliRunner.Run(+ ["asm", "exec", manifestPath, "--json"],+ stdout,+ stderr);++ Assert.Equal(0, exitCode);+ Assert.True(string.IsNullOrWhiteSpace(stderr.ToString()));++ using var doc = JsonDocument.Parse(stdout.ToString());+ var root = doc.RootElement;+ Assert.True(root.GetProperty("success").GetBoolean());+ Assert.Equal(18, root.GetProperty("instanceCount").GetInt32());+ Assert.Equal(18, root.GetProperty("analysis").GetProperty("summary").GetProperty("bodyCount").GetInt32());+ Assert.True(root.GetProperty("analysis").GetProperty("summary").GetProperty("faceCount").GetInt32() > 0);+ }+[Fact]public void Analyze_Command_Reports_Summary_Facts_And_Discoverability(){diff --git a/Aetheris.CLI.Tests/CliHelpAndUsageTests.cs b/Aetheris.CLI.Tests/CliHelpAndUsageTests.csindex 56c111be..202955dc 100644--- a/Aetheris.CLI.Tests/CliHelpAndUsageTests.cs+++ b/Aetheris.CLI.Tests/CliHelpAndUsageTests.cs@@ -19,16 +19,18 @@ public sealed class CliHelpAndUsageTestsAssert.Equal(0, exitCode);Assert.True(string.IsNullOrWhiteSpace(stderr.ToString()));var text = stdout.ToString();- Assert.Contains("Usage: aetheris <build|analyze|canon>", text, StringComparison.Ordinal);+ Assert.Contains("Usage: aetheris <build|analyze|canon|asm>", text, StringComparison.Ordinal);Assert.Contains("Commands:", text, StringComparison.Ordinal);Assert.Contains("build", text, StringComparison.Ordinal);Assert.Contains("analyze", text, StringComparison.Ordinal);Assert.Contains("canon", text, StringComparison.Ordinal);+ Assert.Contains("asm", text, StringComparison.Ordinal);}[Theory][InlineData("build")][InlineData("canon")]+ [InlineData("asm")][InlineData("analyze")][InlineData("analyze", "map")][InlineData("analyze", "section")]diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.csindex e5eff79e..c9ea8dcc 100644--- a/Aetheris.CLI/CliRunner.cs+++ b/Aetheris.CLI/CliRunner.cs@@ -1,17 +1,19 @@using System.Text.Json;using System.Text.Json.Serialization;using Aetheris.Kernel.Firmament;+using Aetheris.Kernel.Firmament.Assembly;namespace Aetheris.CLI;public static class CliRunner{- private const string TopLevelUsage = "Usage: aetheris <build|analyze|canon> <path> [options]";+ private const string TopLevelUsage = "Usage: aetheris <build|analyze|canon|asm> <path> [options]";private const string BuildUsage = "Usage: aetheris build <file.firmament> [--out <path>] [--json]";private const string AnalyzeUsage = "Usage: aetheris analyze <file.step> [--face <id>] [--edge <id>] [--vertex <id>] [--json]";private const string AnalyzeMapUsage = "Usage: aetheris analyze map <file.step> (--top|--bottom|--front|--back|--left|--right) --rows <N> --cols <N> --json";private const string AnalyzeSectionUsage = "Usage: aetheris analyze section <file.step> (--xy|--xz|--yz) --offset <value> --json";private const string CanonUsage = "Usage: aetheris canon <file.step> --out <canonical.step> [--json]";+ private const string AsmExecUsage = "Usage: aetheris asm exec <file.firmasm> [--json]";private static readonly JsonSerializerOptions JsonOptions = new(){@@ -52,6 +54,7 @@ public static class CliRunner"build" => RunBuild(args.Skip(1).ToArray(), stdout, stderr),"analyze" => RunAnalyze(args.Skip(1).ToArray(), stdout, stderr),"canon" => RunCanon(args.Skip(1).ToArray(), stdout, stderr),+ "asm" => RunAsm(args.Skip(1).ToArray(), stdout, stderr),_ => UnknownCommand(args[0], stderr)};}@@ -509,6 +512,116 @@ public static class CliRunnerreturn 0;}+ private static int RunAsm(string[] args, TextWriter stdout, TextWriter stderr)+ {+ if (args.Length == 0 || IsHelpFlag(args[0]))+ {+ WriteAsmHelp(stdout);+ return args.Length == 0 ? 1 : 0;+ }++ if (!string.Equals(args[0], "exec", StringComparison.Ordinal))+ {+ stderr.WriteLine($"Unknown asm subcommand '{args[0]}'.");+ stderr.WriteLine(AsmExecUsage);+ return 1;+ }++ return RunAsmExec(args.Skip(1).ToArray(), stdout, stderr);+ }++ private static int RunAsmExec(string[] args, TextWriter stdout, TextWriter stderr)+ {+ if (args.Length == 0)+ {+ stderr.WriteLine(AsmExecUsage);+ stderr.WriteLine("Run 'aetheris asm --help' for examples.");+ return 1;+ }++ if (IsHelpFlag(args[0]))+ {+ WriteAsmHelp(stdout);+ return 0;+ }++ if (args[0].StartsWith("-", StringComparison.Ordinal))+ {+ stderr.WriteLine("Asm exec requires <file.firmasm> as the first argument.");+ stderr.WriteLine(AsmExecUsage);+ return 1;+ }++ var manifestPath = args[0];+ var json = false;+ for (var i = 1; i < args.Length; i++)+ {+ switch (args[i])+ {+ case "--json":+ json = true;+ break;+ case "-h":+ case "--help":+ WriteAsmHelp(stdout);+ return 0;+ default:+ stderr.WriteLine($"Unknown asm exec option '{args[i]}'.");+ stderr.WriteLine(AsmExecUsage);+ return 1;+ }+ }++ var executor = new FirmasmAssemblyExecutor();+ var execute = executor.ExecuteFromFile(manifestPath);+ if (!execute.IsSuccess)+ {+ if (json)+ {+ stdout.WriteLine(JsonSerializer.Serialize(new+ {+ success = false,+ manifestPath = Path.GetFullPath(manifestPath),+ diagnostics = execute.Diagnostics.Select(d => new { d.Source, d.Message, severity = d.Severity.ToString() })+ }, JsonOptions));+ }+ else+ {+ stderr.WriteLine("ASM execution failed:");+ foreach (var diagnostic in execute.Diagnostics)+ {+ stderr.WriteLine($"- [{diagnostic.Severity}] {diagnostic.Source}: {diagnostic.Message}");+ }+ }++ return 1;+ }++ var analysis = StepAnalyzer.AnalyzeImportedBody(execute.Value.ComposedBody, Path.GetFullPath(manifestPath));+ if (json)+ {+ stdout.WriteLine(JsonSerializer.Serialize(new+ {+ success = true,+ manifestPath = execute.Value.LoadedAssembly.SourcePath,+ assemblyName = execute.Value.LoadedAssembly.Manifest.Assembly.Name,+ partCount = execute.Value.LoadedAssembly.LoadedParts.Count,+ instanceCount = execute.Value.Instances.Count,+ bodyCount = execute.Value.ComposedBody.Topology.Bodies.Count(),+ shellCount = execute.Value.ComposedBody.Topology.Shells.Count(),+ boundingBox = analysis.Summary.BoundingBox,+ analysis+ }, JsonOptions));+ return 0;+ }++ stdout.WriteLine($"ASM execution succeeded: {execute.Value.LoadedAssembly.Manifest.Assembly.Name}");+ stdout.WriteLine($"Parts: {execute.Value.LoadedAssembly.LoadedParts.Count}");+ stdout.WriteLine($"Instances: {execute.Value.Instances.Count}");+ stdout.WriteLine($"Bodies: {execute.Value.ComposedBody.Topology.Bodies.Count()}");+ return 0;+ }+private static int RunAnalyzeMap(string[] args, TextWriter stdout, TextWriter stderr){if (args.Length == 0)@@ -785,7 +898,7 @@ public static class CliRunnerprivate static int UnknownCommand(string command, TextWriter stderr){- stderr.WriteLine($"Unknown command '{command}'. Expected one of: build, analyze, canon.");+ stderr.WriteLine($"Unknown command '{command}'. Expected one of: build, analyze, canon, asm.");stderr.WriteLine("Run 'aetheris --help' for usage and examples.");return 1;}@@ -814,6 +927,7 @@ public static class CliRunnerstdout.WriteLine(" build Build a .firmament source file into STEP.");stdout.WriteLine(" analyze Analyze STEP topology, geometry, map, and sections.");stdout.WriteLine(" canon Import and re-export STEP/AP242 as canonical STEP.");+ stdout.WriteLine(" asm Execute .firmasm assembly IR into composed world-space geometry.");stdout.WriteLine();stdout.WriteLine("Global options:");stdout.WriteLine(" -h, --help Show help.");@@ -823,6 +937,7 @@ public static class CliRunnerstdout.WriteLine(" aetheris build model.firmament --out model.step");stdout.WriteLine(" aetheris analyze model.step --json");stdout.WriteLine(" aetheris canon input.step --out canonical.step --json");+ stdout.WriteLine(" aetheris asm exec assembly.firmasm --json");stdout.WriteLine(" aetheris analyze map model.step --top --rows 40 --cols 60 --json");stdout.WriteLine(" aetheris analyze section model.step --xy --offset 2.5 --json");stdout.WriteLine();@@ -917,6 +1032,20 @@ public static class CliRunnerstdout.WriteLine(" aetheris canon input.step --out canonical.step --json");}+ private static void WriteAsmHelp(TextWriter stdout)+ {+ stdout.WriteLine("Execute flattened .firmasm assemblies as rigidly placed body instances.");+ stdout.WriteLine();+ stdout.WriteLine(AsmExecUsage);+ stdout.WriteLine();+ stdout.WriteLine("Options:");+ stdout.WriteLine(" --json Emit machine-readable execution and analyzer JSON.");+ stdout.WriteLine(" -h, --help Show this help.");+ stdout.WriteLine();+ stdout.WriteLine("Example:");+ stdout.WriteLine(" aetheris asm exec testdata/firmasm/examples/occt-as1/as1-assembly.firmasm --json");+ }+private static string FormatBox(Aetheris.Kernel.Core.Math.BoundingBox3D? box) =>box is null ? "unknown" : $"min{FormatPoint(box.Value.Min)} max{FormatPoint(box.Value.Max)}";diff --git a/Aetheris.Kernel.Firmament.Tests/Assembly/FirmasmAssemblyExecutorTests.cs b/Aetheris.Kernel.Firmament.Tests/Assembly/FirmasmAssemblyExecutorTests.csnew file mode 100644index 00000000..81d37f3a--- /dev/null+++ b/Aetheris.Kernel.Firmament.Tests/Assembly/FirmasmAssemblyExecutorTests.cs@@ -0,0 +1,64 @@+using Aetheris.Kernel.Firmament.Assembly;++namespace Aetheris.Kernel.Firmament.Tests.Assembly;++public sealed class FirmasmAssemblyExecutorTests+{+ [Fact]+ public void Execute_OcctNutBoltAssembly_ComposesTwoWorldSpaceBodies()+ {+ var executor = new FirmasmAssemblyExecutor();+ var path = FirmamentCorpusHarness.ResolveFixtureFullPath("testdata/firmasm/examples/occt-nut-bolt/nut-bolt-assembly.firmasm");++ var result = executor.ExecuteFromFile(path);++ Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => d.Message)));+ Assert.Equal(2, result.Value.Instances.Count);+ Assert.Equal(2, result.Value.ComposedBody.Topology.Bodies.Count());+ Assert.Equal(result.Value.Instances.Count, result.Value.ComposedBody.Topology.Bodies.Count());+ }++ [Fact]+ public void Execute_OcctAs1Assembly_ComposesAllInstances()+ {+ var executor = new FirmasmAssemblyExecutor();+ var path = FirmamentCorpusHarness.ResolveFixtureFullPath("testdata/firmasm/examples/occt-as1/as1-assembly.firmasm");++ var result = executor.ExecuteFromFile(path);++ Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => d.Message)));+ Assert.Equal(18, result.Value.Instances.Count);+ Assert.Equal(18, result.Value.ComposedBody.Topology.Bodies.Count());+ Assert.True(result.Value.ComposedBody.Topology.Faces.Count() > 0);+ Assert.True(result.Value.ComposedBody.Topology.Vertices.Count() > 0);+ }++ [Fact]+ public void Execute_TransformsMoveInstancesAwayFromOrigin()+ {+ var executor = new FirmasmAssemblyExecutor();+ var path = FirmamentCorpusHarness.ResolveFixtureFullPath("testdata/firmasm/examples/occt-nut-bolt/nut-bolt-assembly.firmasm");++ var result = executor.ExecuteFromFile(path);++ Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(d => d.Message)));++ var minByInstance = result.Value.Instances+ .Select(instance =>+ {+ var points = instance.Body.Topology.Vertices+ .Select(vertex => instance.Body.TryGetVertexPoint(vertex.Id, out var p) ? p : (Aetheris.Kernel.Core.Math.Point3D?)null)+ .Where(p => p.HasValue)+ .Select(p => p!.Value)+ .ToArray();+ Assert.NotEmpty(points);+ return (instance.InstanceId, MinX: points.Min(p => p.X));+ })+ .OrderBy(x => x.InstanceId)+ .ToArray();++ Assert.Equal(2, minByInstance.Length);+ Assert.NotEqual(minByInstance[0].MinX, minByInstance[1].MinX);+ Assert.True(minByInstance.Any(x => Math.Abs(x.MinX) > 1e-3d));+ }+}diff --git a/Aetheris.Kernel.Firmament/Assembly/FirmasmAssemblyExecutor.cs b/Aetheris.Kernel.Firmament/Assembly/FirmasmAssemblyExecutor.csnew file mode 100644index 00000000..4bab0da7--- /dev/null+++ b/Aetheris.Kernel.Firmament/Assembly/FirmasmAssemblyExecutor.cs@@ -0,0 +1,338 @@+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Diagnostics;+using Aetheris.Kernel.Core.Geometry;+using Aetheris.Kernel.Core.Geometry.Curves;+using Aetheris.Kernel.Core.Geometry.Surfaces;+using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Core.Numerics;+using Aetheris.Kernel.Core.Results;+using Aetheris.Kernel.Core.Topology;++namespace Aetheris.Kernel.Firmament.Assembly;++public sealed record FirmasmExecutedInstance(+ string InstanceId,+ string PartName,+ string ResolvedPath,+ BrepBody Body,+ Transform3D WorldTransform);++public sealed record FirmasmExecutionResult(+ FirmasmLoadedAssembly LoadedAssembly,+ IReadOnlyList<FirmasmExecutedInstance> Instances,+ BrepBody ComposedBody);++public sealed class FirmasmAssemblyExecutor+{+ private readonly FirmasmManifestLoader _loader = new();++ public KernelResult<FirmasmExecutionResult> ExecuteFromFile(string manifestPath)+ {+ var loadResult = _loader.LoadFromFile(manifestPath);+ if (!loadResult.IsSuccess)+ {+ return KernelResult<FirmasmExecutionResult>.Failure(loadResult.Diagnostics);+ }++ return Execute(loadResult.Value);+ }++ public KernelResult<FirmasmExecutionResult> Execute(FirmasmLoadedAssembly loadedAssembly)+ {+ ArgumentNullException.ThrowIfNull(loadedAssembly);++ var instances = new List<FirmasmExecutedInstance>(loadedAssembly.Manifest.Instances.Count);+ foreach (var instance in loadedAssembly.Manifest.Instances)+ {+ if (!loadedAssembly.LoadedParts.TryGetValue(instance.Part, out var loadedPart))+ {+ return Failure($"Instance '{instance.Id}' references unloaded part '{instance.Part}'.");+ }++ if (loadedPart is not FirmasmLoadedOpaqueStepPart stepPart)+ {+ return Failure($"Instance '{instance.Id}' part '{instance.Part}' has kind '{loadedPart.GetType().Name}' which is not executable in ASM-A3. Only STEP parts are currently supported.");+ }++ var transform = BuildRigidTransform(instance.Transform);+ var transformedBody = TransformBody(stepPart.ImportedBody, transform);+ instances.Add(new FirmasmExecutedInstance(instance.Id, instance.Part, stepPart.ResolvedPath, transformedBody, transform));+ }++ var composedBody = Compose(instances.Select(i => i.Body).ToArray());+ var validation = BrepBindingValidator.Validate(composedBody, requireAllEdgeAndFaceBindings: true);+ if (!validation.IsSuccess)+ {+ return KernelResult<FirmasmExecutionResult>.Failure(validation.Diagnostics);+ }++ return KernelResult<FirmasmExecutionResult>.Success(+ new FirmasmExecutionResult(loadedAssembly, instances, composedBody),+ validation.Diagnostics);+ }++ internal static Transform3D BuildRigidTransform(FirmasmRigidTransform transform)+ {+ ArgumentNullException.ThrowIfNull(transform);++ var world = Transform3D.Identity;+ if (transform.RotateDegXyz is { Count: 3 } rotate)+ {+ world = world+ * Transform3D.CreateRotationX(ToRadians(rotate[0]))+ * Transform3D.CreateRotationY(ToRadians(rotate[1]))+ * Transform3D.CreateRotationZ(ToRadians(rotate[2]));+ }++ var translation = new Vector3D(transform.Translate[0], transform.Translate[1], transform.Translate[2]);+ world = world * Transform3D.CreateTranslation(translation);+ return world;+ }++ private static BrepBody TransformBody(BrepBody sourceBody, Transform3D transform)+ {+ var transformedGeometry = new BrepGeometryStore();+ foreach (var (curveId, curve) in sourceBody.Geometry.Curves)+ {+ transformedGeometry.AddCurve(curveId, TransformCurve(curve, transform));+ }++ foreach (var (surfaceId, surface) in sourceBody.Geometry.Surfaces)+ {+ transformedGeometry.AddSurface(surfaceId, TransformSurface(surface, transform));+ }++ var transformedVertices = new Dictionary<VertexId, Point3D>();+ foreach (var vertex in sourceBody.Topology.Vertices)+ {+ if (sourceBody.TryGetVertexPoint(vertex.Id, out var point))+ {+ transformedVertices[vertex.Id] = transform.Apply(point);+ }+ }++ return new BrepBody(+ sourceBody.Topology,+ transformedGeometry,+ sourceBody.Bindings,+ transformedVertices,+ sourceBody.SafeBooleanComposition,+ sourceBody.ShellRepresentation);+ }++ private static CurveGeometry TransformCurve(CurveGeometry curve, Transform3D transform)+ {+ return curve.Kind switch+ {+ CurveGeometryKind.Line3 => CurveGeometry.FromLine(new Line3Curve(+ transform.Apply(curve.Line3!.Value.Origin),+ transform.Apply(curve.Line3.Value.Direction, ToleranceContext.Default))),+ CurveGeometryKind.Circle3 => CurveGeometry.FromCircle(new Circle3Curve(+ transform.Apply(curve.Circle3!.Value.Center),+ transform.Apply(curve.Circle3.Value.Normal, ToleranceContext.Default),+ curve.Circle3.Value.Radius,+ transform.Apply(curve.Circle3.Value.XAxis, ToleranceContext.Default))),+ CurveGeometryKind.BSpline3 => CurveGeometry.FromBSpline(new BSpline3Curve(+ curve.BSpline3!.Value.Degree,+ curve.BSpline3.Value.ControlPoints.Select(transform.Apply).ToArray(),+ curve.BSpline3.Value.KnotMultiplicities,+ curve.BSpline3.Value.KnotValues,+ curve.BSpline3.Value.CurveForm,+ curve.BSpline3.Value.ClosedCurve,+ curve.BSpline3.Value.SelfIntersect,+ curve.BSpline3.Value.KnotSpec)),+ CurveGeometryKind.Ellipse3 => CurveGeometry.FromEllipse(new Ellipse3Curve(+ transform.Apply(curve.Ellipse3!.Value.Center),+ transform.Apply(curve.Ellipse3.Value.Normal, ToleranceContext.Default),+ curve.Ellipse3.Value.MajorRadius,+ curve.Ellipse3.Value.MinorRadius,+ transform.Apply(curve.Ellipse3.Value.XAxis, ToleranceContext.Default))),+ _ => curve+ };+ }++ private static SurfaceGeometry TransformSurface(SurfaceGeometry surface, Transform3D transform)+ {+ return surface.Kind switch+ {+ SurfaceGeometryKind.Plane => SurfaceGeometry.FromPlane(new PlaneSurface(+ transform.Apply(surface.Plane!.Value.Origin),+ transform.Apply(surface.Plane.Value.Normal, ToleranceContext.Default),+ transform.Apply(surface.Plane.Value.UAxis, ToleranceContext.Default))),+ SurfaceGeometryKind.Cylinder => SurfaceGeometry.FromCylinder(new CylinderSurface(+ transform.Apply(surface.Cylinder!.Value.Origin),+ transform.Apply(surface.Cylinder.Value.Axis, ToleranceContext.Default),+ surface.Cylinder.Value.Radius,+ transform.Apply(surface.Cylinder.Value.XAxis, ToleranceContext.Default))),+ SurfaceGeometryKind.Cone => SurfaceGeometry.FromCone(new ConeSurface(+ transform.Apply(surface.Cone!.Value.PlacementOrigin),+ transform.Apply(surface.Cone.Value.Axis, ToleranceContext.Default),+ surface.Cone.Value.PlacementRadius,+ surface.Cone.Value.SemiAngleRadians,+ transform.Apply(surface.Cone.Value.ReferenceAxis, ToleranceContext.Default))),+ SurfaceGeometryKind.Sphere => SurfaceGeometry.FromSphere(new SphereSurface(+ transform.Apply(surface.Sphere!.Value.Center),+ transform.Apply(surface.Sphere.Value.Axis, ToleranceContext.Default),+ surface.Sphere.Value.Radius,+ transform.Apply(surface.Sphere.Value.XAxis, ToleranceContext.Default))),+ SurfaceGeometryKind.Torus => SurfaceGeometry.FromTorus(new TorusSurface(+ transform.Apply(surface.Torus!.Value.Center),+ transform.Apply(surface.Torus.Value.Axis, ToleranceContext.Default),+ surface.Torus.Value.MajorRadius,+ surface.Torus.Value.MinorRadius,+ transform.Apply(surface.Torus.Value.XAxis, ToleranceContext.Default))),+ SurfaceGeometryKind.BSplineSurfaceWithKnots => SurfaceGeometry.FromBSplineSurfaceWithKnots(new BSplineSurfaceWithKnots(+ surface.BSplineSurfaceWithKnots!.DegreeU,+ surface.BSplineSurfaceWithKnots.DegreeV,+ surface.BSplineSurfaceWithKnots.ControlPoints.Select(row => row.Select(transform.Apply).ToArray()).ToArray(),+ surface.BSplineSurfaceWithKnots.SurfaceForm,+ surface.BSplineSurfaceWithKnots.UClosed,+ surface.BSplineSurfaceWithKnots.VClosed,+ surface.BSplineSurfaceWithKnots.SelfIntersect,+ surface.BSplineSurfaceWithKnots.KnotMultiplicitiesU,+ surface.BSplineSurfaceWithKnots.KnotMultiplicitiesV,+ surface.BSplineSurfaceWithKnots.KnotValuesU,+ surface.BSplineSurfaceWithKnots.KnotValuesV,+ surface.BSplineSurfaceWithKnots.KnotSpec)),+ _ => surface+ };+ }++ private static BrepBody Compose(IReadOnlyList<BrepBody> bodies)+ {+ if (bodies.Count == 0)+ {+ throw new InvalidOperationException("At least one body must be provided for assembly composition.");+ }++ var topology = new TopologyModel();+ var geometry = new BrepGeometryStore();+ var bindings = new BrepBindingModel();+ var vertexPoints = new Dictionary<VertexId, Point3D>();++ var nextVertexId = 1;+ var nextEdgeId = 1;+ var nextCoedgeId = 1;+ var nextLoopId = 1;+ var nextFaceId = 1;+ var nextShellId = 1;+ var nextBodyId = 1;+ var nextCurveId = 1;+ var nextSurfaceId = 1;++ foreach (var sourceBody in bodies)+ {+ var vertexMap = sourceBody.Topology.Vertices+ .OrderBy(v => v.Id.Value)+ .ToDictionary(v => v.Id, _ => new VertexId(nextVertexId++));+ foreach (var (oldVertexId, newVertexId) in vertexMap)+ {+ topology.AddVertex(new Vertex(newVertexId));+ if (sourceBody.TryGetVertexPoint(oldVertexId, out var point))+ {+ vertexPoints[newVertexId] = point;+ }+ }++ var edgeMap = sourceBody.Topology.Edges+ .OrderBy(e => e.Id.Value)+ .ToDictionary(e => e.Id, _ => new EdgeId(nextEdgeId++));+ foreach (var edge in sourceBody.Topology.Edges.OrderBy(e => e.Id.Value))+ {+ topology.AddEdge(new Edge(edgeMap[edge.Id], vertexMap[edge.StartVertexId], vertexMap[edge.EndVertexId]));+ }++ var coedgeMap = sourceBody.Topology.Coedges+ .OrderBy(c => c.Id.Value)+ .ToDictionary(c => c.Id, _ => new CoedgeId(nextCoedgeId++));+ var loopMap = sourceBody.Topology.Loops+ .OrderBy(l => l.Id.Value)+ .ToDictionary(l => l.Id, _ => new LoopId(nextLoopId++));+ var faceMap = sourceBody.Topology.Faces+ .OrderBy(f => f.Id.Value)+ .ToDictionary(f => f.Id, _ => new FaceId(nextFaceId++));+ var shellMap = sourceBody.Topology.Shells+ .OrderBy(s => s.Id.Value)+ .ToDictionary(s => s.Id, _ => new ShellId(nextShellId++));+ var bodyMap = sourceBody.Topology.Bodies+ .OrderBy(b => b.Id.Value)+ .ToDictionary(b => b.Id, _ => new BodyId(nextBodyId++));++ foreach (var coedge in sourceBody.Topology.Coedges.OrderBy(c => c.Id.Value))+ {+ topology.AddCoedge(new Coedge(+ coedgeMap[coedge.Id],+ edgeMap[coedge.EdgeId],+ loopMap[coedge.LoopId],+ coedgeMap[coedge.NextCoedgeId],+ coedgeMap[coedge.PrevCoedgeId],+ coedge.IsReversed));+ }++ foreach (var loop in sourceBody.Topology.Loops.OrderBy(l => l.Id.Value))+ {+ topology.AddLoop(new Loop(loopMap[loop.Id], loop.CoedgeIds.Select(id => coedgeMap[id]).ToArray()));+ }++ foreach (var face in sourceBody.Topology.Faces.OrderBy(f => f.Id.Value))+ {+ topology.AddFace(new Face(faceMap[face.Id], face.LoopIds.Select(id => loopMap[id]).ToArray()));+ }++ foreach (var shell in sourceBody.Topology.Shells.OrderBy(s => s.Id.Value))+ {+ topology.AddShell(new Shell(shellMap[shell.Id], shell.FaceIds.Select(id => faceMap[id]).ToArray()));+ }++ foreach (var body in sourceBody.Topology.Bodies.OrderBy(b => b.Id.Value))+ {+ topology.AddBody(new Body(bodyMap[body.Id], body.ShellIds.Select(id => shellMap[id]).ToArray()));+ }++ var curveMap = sourceBody.Geometry.Curves+ .OrderBy(c => c.Key.Value)+ .ToDictionary(c => c.Key, _ => new CurveGeometryId(nextCurveId++));+ foreach (var (curveId, curve) in sourceBody.Geometry.Curves.OrderBy(c => c.Key.Value))+ {+ geometry.AddCurve(curveMap[curveId], curve);+ }++ var surfaceMap = sourceBody.Geometry.Surfaces+ .OrderBy(s => s.Key.Value)+ .ToDictionary(s => s.Key, _ => new SurfaceGeometryId(nextSurfaceId++));+ foreach (var (surfaceId, surface) in sourceBody.Geometry.Surfaces.OrderBy(s => s.Key.Value))+ {+ geometry.AddSurface(surfaceMap[surfaceId], surface);+ }++ foreach (var edgeBinding in sourceBody.Bindings.EdgeBindings.OrderBy(b => b.EdgeId.Value))+ {+ bindings.AddEdgeBinding(new EdgeGeometryBinding(+ edgeMap[edgeBinding.EdgeId],+ curveMap[edgeBinding.CurveGeometryId],+ edgeBinding.TrimInterval,+ edgeBinding.OrientedEdgeSense));+ }++ foreach (var faceBinding in sourceBody.Bindings.FaceBindings.OrderBy(b => b.FaceId.Value))+ {+ bindings.AddFaceBinding(new FaceGeometryBinding(faceMap[faceBinding.FaceId], surfaceMap[faceBinding.SurfaceGeometryId]));+ }+ }++ return new BrepBody(topology, geometry, bindings, vertexPoints);+ }++ private static double ToRadians(double degrees) => degrees * (double.Pi / 180d);++ private static KernelResult<FirmasmExecutionResult> Failure(string message)+ {+ return KernelResult<FirmasmExecutionResult>.Failure([+ new KernelDiagnostic(+ KernelDiagnosticCode.ValidationFailed,+ KernelDiagnosticSeverity.Error,+ message,+ Source: "firmasm")+ ]);+ }+}