Skip to content

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.cs
index a32bf8f3..3659e992 100644
--- a/Aetheris.CLI.Tests/CliBaselineTests.cs
+++ b/Aetheris.CLI.Tests/CliBaselineTests.cs
@@ -31,6 +31,52 @@ public sealed class CliBaselineTests
File.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.cs
index 56c111be..202955dc 100644
--- a/Aetheris.CLI.Tests/CliHelpAndUsageTests.cs
+++ b/Aetheris.CLI.Tests/CliHelpAndUsageTests.cs
@@ -19,16 +19,18 @@ public sealed class CliHelpAndUsageTests
Assert.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.cs
index 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 CliRunner
return 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 CliRunner
private 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 CliRunner
stdout.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 CliRunner
stdout.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 CliRunner
stdout.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.cs
new file mode 100644
index 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.cs
new file mode 100644
index 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")
+ ]);
+ }
+}