Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add CIR linear tape lowering and point interpreter
Yuechen Lia352c7a8a6e3
diff --git a/Aetheris.Kernel.Core.Tests/Cir/CirTapeEvaluationTests.cs b/Aetheris.Kernel.Core.Tests/Cir/CirTapeEvaluationTests.csnew file mode 100644index 00000000..bc94abb3--- /dev/null+++ b/Aetheris.Kernel.Core.Tests/Cir/CirTapeEvaluationTests.cs@@ -0,0 +1,82 @@+using Aetheris.Kernel.Core.Cir;+using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Core.Numerics;++namespace Aetheris.Kernel.Core.Tests.Cir;++public sealed class CirTapeEvaluationTests+{+ [Fact]+ public void Tape_Box_MatchesRecursiveEvaluate()+ {+ var node = new CirBoxNode(10d, 8d, 6d);+ AssertTapeMatches(node, new Point3D(0d, 0d, 0d), new Point3D(6d, 0d, 0d), new Point3D(5d, 0d, 0d));+ }++ [Fact]+ public void Tape_Cylinder_MatchesRecursiveEvaluate()+ {+ var node = new CirCylinderNode(3d, 10d);+ AssertTapeMatches(node, new Point3D(1d, 1d, 0d), new Point3D(4d, 0d, 0d), new Point3D(3d, 0d, 0d));+ }++ [Fact]+ public void Tape_Sphere_MatchesRecursiveEvaluate()+ {+ var node = new CirSphereNode(5d);+ AssertTapeMatches(node, new Point3D(0d, 0d, 0d), new Point3D(6d, 0d, 0d), new Point3D(5d, 0d, 0d));+ }++ [Fact]+ public void Tape_BoxMinusCylinder_MatchesRecursiveEvaluate()+ {+ var node = new CirSubtractNode(new CirBoxNode(20d, 20d, 20d), new CirCylinderNode(3d, 24d));+ AssertTapeMatches(node, new Point3D(8d, 0d, 0d), new Point3D(0d, 0d, 0d), new Point3D(3d, 0d, 0d));+ }++ [Fact]+ public void Tape_UnionIntersect_MatchesRecursiveEvaluate()+ {+ var union = new CirUnionNode(new CirSphereNode(3d), new CirBoxNode(4d, 4d, 4d));+ var node = new CirIntersectNode(union, new CirCylinderNode(4d, 6d));+ AssertTapeMatches(node, new Point3D(0d, 0d, 0d), new Point3D(4d, 4d, 0d), new Point3D(0d, 0d, 3d));+ }++ [Fact]+ public void Tape_Transform_MatchesRecursiveEvaluate()+ {+ var transform = Transform3D.CreateTranslation(new Vector3D(2d, -1d, 3d)) * Transform3D.CreateRotationZ(double.Pi / 6d);+ var node = new CirTransformNode(new CirBoxNode(4d, 2d, 6d), transform);+ AssertTapeMatches(node, new Point3D(2d, -1d, 3d), new Point3D(7d, -1d, 3d), new Point3D(4d, 0d, 3d));+ }++ [Fact]+ public void Tape_DeterministicLowering()+ {+ var node = new CirSubtractNode(+ new CirUnionNode(new CirBoxNode(8d, 8d, 8d), new CirSphereNode(6d)),+ new CirTransformNode(new CirCylinderNode(2d, 12d), Transform3D.CreateTranslation(new Vector3D(1d, 2d, 0d))));++ var first = CirTapeLowerer.Lower(node);+ var second = CirTapeLowerer.Lower(node);++ Assert.Equal(first.OutputSlot, second.OutputSlot);+ Assert.Equal(first.SlotCount, second.SlotCount);+ Assert.Equal(first.Instructions, second.Instructions);+ Assert.Equal(first.BoxPayloads, second.BoxPayloads);+ Assert.Equal(first.CylinderPayloads, second.CylinderPayloads);+ Assert.Equal(first.SpherePayloads, second.SpherePayloads);++ var probe = new Point3D(1.25d, -0.5d, 2d);+ Assert.Equal(first.Evaluate(probe), second.Evaluate(probe), 12);+ }++ private static void AssertTapeMatches(CirNode node, params Point3D[] points)+ {+ var tape = CirTapeLowerer.Lower(node);+ foreach (var point in points)+ {+ Assert.Equal(node.Evaluate(point), tape.Evaluate(point), 12);+ }+ }+}diff --git a/Aetheris.Kernel.Core/Cir/CirTape.cs b/Aetheris.Kernel.Core/Cir/CirTape.csnew file mode 100644index 00000000..d2c025c0--- /dev/null+++ b/Aetheris.Kernel.Core/Cir/CirTape.cs@@ -0,0 +1,232 @@+using Aetheris.Kernel.Core.Math;++namespace Aetheris.Kernel.Core.Cir;++public enum CirTapeOpCode+{+ EvalBox,+ EvalCylinder,+ EvalSphere,+ Min,+ Max,+ Neg,+ EvalTransform,+}++public readonly record struct CirTapeInstruction(+ CirTapeOpCode OpCode,+ int DestSlot,+ int InputA,+ int InputB,+ int PayloadIndex,+ CirNodeKind SourceKind,+ int LoweringIndex);++public readonly record struct CirTapeBoxPayload(double Width, double Height, double Depth);+public readonly record struct CirTapeCylinderPayload(double Radius, double Height);+public readonly record struct CirTapeSpherePayload(double Radius);+public readonly record struct CirTapeTransformPayload(Transform3D InverseTransform);+public readonly record struct CirTapeTransformEvalPayload(CirNode Child, Transform3D InverseTransform);++public sealed class CirTape+{+ public CirTape(+ IReadOnlyList<CirTapeInstruction> instructions,+ IReadOnlyList<CirTapeBoxPayload> boxes,+ IReadOnlyList<CirTapeCylinderPayload> cylinders,+ IReadOnlyList<CirTapeSpherePayload> spheres,+ IReadOnlyList<CirTapeTransformPayload> transforms,+ IReadOnlyList<CirTapeTransformEvalPayload> transformEvals,+ int outputSlot,+ int slotCount)+ {+ Instructions = instructions;+ BoxPayloads = boxes;+ CylinderPayloads = cylinders;+ SpherePayloads = spheres;+ TransformPayloads = transforms;+ TransformEvalPayloads = transformEvals;+ OutputSlot = outputSlot;+ SlotCount = slotCount;+ }++ public IReadOnlyList<CirTapeInstruction> Instructions { get; }+ public IReadOnlyList<CirTapeBoxPayload> BoxPayloads { get; }+ public IReadOnlyList<CirTapeCylinderPayload> CylinderPayloads { get; }+ public IReadOnlyList<CirTapeSpherePayload> SpherePayloads { get; }+ public IReadOnlyList<CirTapeTransformPayload> TransformPayloads { get; }+ public IReadOnlyList<CirTapeTransformEvalPayload> TransformEvalPayloads { get; }+ public int OutputSlot { get; }+ public int SlotCount { get; }++ public double Evaluate(Point3D point)+ {+ var slots = new double[SlotCount];++ foreach (var instruction in Instructions)+ {+ switch (instruction.OpCode)+ {+ case CirTapeOpCode.EvalBox:+ {+ var payload = BoxPayloads[instruction.PayloadIndex];+ slots[instruction.DestSlot] = EvaluateBox(point, payload);+ break;+ }+ case CirTapeOpCode.EvalCylinder:+ {+ var payload = CylinderPayloads[instruction.PayloadIndex];+ slots[instruction.DestSlot] = EvaluateCylinder(point, payload);+ break;+ }+ case CirTapeOpCode.EvalSphere:+ {+ var payload = SpherePayloads[instruction.PayloadIndex];+ slots[instruction.DestSlot] = EvaluateSphere(point, payload);+ break;+ }+ case CirTapeOpCode.Min:+ slots[instruction.DestSlot] = double.Min(slots[instruction.InputA], slots[instruction.InputB]);+ break;+ case CirTapeOpCode.Max:+ slots[instruction.DestSlot] = double.Max(slots[instruction.InputA], slots[instruction.InputB]);+ break;+ case CirTapeOpCode.Neg:+ slots[instruction.DestSlot] = -slots[instruction.InputA];+ break;+ case CirTapeOpCode.EvalTransform:+ {+ var payload = TransformEvalPayloads[instruction.PayloadIndex];+ slots[instruction.DestSlot] = payload.Child.Evaluate(payload.InverseTransform.Apply(point));+ break;+ }+ default:+ throw new InvalidOperationException($"Unsupported CIR tape opcode: {instruction.OpCode}.");+ }+ }++ return slots[OutputSlot];+ }++ private static double EvaluateBox(Point3D point, CirTapeBoxPayload payload)+ {+ var hx = payload.Width * 0.5d;+ var hy = payload.Height * 0.5d;+ var hz = payload.Depth * 0.5d;+ var dx = double.Abs(point.X) - hx;+ var dy = double.Abs(point.Y) - hy;+ var dz = double.Abs(point.Z) - hz;+ var outsideX = double.Max(dx, 0d);+ var outsideY = double.Max(dy, 0d);+ var outsideZ = double.Max(dz, 0d);+ var outside = double.Sqrt((outsideX * outsideX) + (outsideY * outsideY) + (outsideZ * outsideZ));+ var inside = double.Min(double.Max(dx, double.Max(dy, dz)), 0d);+ return outside + inside;+ }++ private static double EvaluateCylinder(Point3D point, CirTapeCylinderPayload payload)+ {+ var radial = double.Sqrt((point.X * point.X) + (point.Y * point.Y));+ var dr = radial - payload.Radius;+ var dz = double.Abs(point.Z) - (payload.Height * 0.5d);+ var outsideR = double.Max(dr, 0d);+ var outsideZ = double.Max(dz, 0d);+ var outside = double.Sqrt((outsideR * outsideR) + (outsideZ * outsideZ));+ var inside = double.Min(double.Max(dr, dz), 0d);+ return outside + inside;+ }++ private static double EvaluateSphere(Point3D point, CirTapeSpherePayload payload) =>+ double.Sqrt((point.X * point.X) + (point.Y * point.Y) + (point.Z * point.Z)) - payload.Radius;+}++public static class CirTapeLowerer+{+ public static CirTape Lower(CirNode node)+ {+ ArgumentNullException.ThrowIfNull(node);++ var state = new LoweringState();+ var outputSlot = LowerNode(node, state);++ return new CirTape(+ state.Instructions,+ state.BoxPayloads,+ state.CylinderPayloads,+ state.SpherePayloads,+ state.TransformPayloads,+ state.TransformEvalPayloads,+ outputSlot,+ state.NextSlot);+ }++ private static int LowerNode(CirNode node, LoweringState state)+ {+ switch (node)+ {+ case CirBoxNode box:+ {+ var payloadIndex = state.BoxPayloads.Count;+ state.BoxPayloads.Add(new CirTapeBoxPayload(box.Width, box.Height, box.Depth));+ return state.Emit(CirTapeOpCode.EvalBox, -1, -1, payloadIndex, node.Kind);+ }+ case CirCylinderNode cylinder:+ {+ var payloadIndex = state.CylinderPayloads.Count;+ state.CylinderPayloads.Add(new CirTapeCylinderPayload(cylinder.Radius, cylinder.Height));+ return state.Emit(CirTapeOpCode.EvalCylinder, -1, -1, payloadIndex, node.Kind);+ }+ case CirSphereNode sphere:+ {+ var payloadIndex = state.SpherePayloads.Count;+ state.SpherePayloads.Add(new CirTapeSpherePayload(sphere.Radius));+ return state.Emit(CirTapeOpCode.EvalSphere, -1, -1, payloadIndex, node.Kind);+ }+ case CirUnionNode union:+ {+ var left = LowerNode(union.Left, state);+ var right = LowerNode(union.Right, state);+ return state.Emit(CirTapeOpCode.Min, left, right, -1, node.Kind);+ }+ case CirSubtractNode subtract:+ {+ var left = LowerNode(subtract.Left, state);+ var right = LowerNode(subtract.Right, state);+ var negRight = state.Emit(CirTapeOpCode.Neg, right, -1, -1, node.Kind);+ return state.Emit(CirTapeOpCode.Max, left, negRight, -1, node.Kind);+ }+ case CirIntersectNode intersect:+ {+ var left = LowerNode(intersect.Left, state);+ var right = LowerNode(intersect.Right, state);+ return state.Emit(CirTapeOpCode.Max, left, right, -1, node.Kind);+ }+ case CirTransformNode transform:+ {+ var payloadIndex = state.TransformEvalPayloads.Count;+ state.TransformEvalPayloads.Add(new CirTapeTransformEvalPayload(transform.Child, transform.Transform.Inverse()));+ return state.Emit(CirTapeOpCode.EvalTransform, -1, -1, payloadIndex, node.Kind);+ }+ default:+ throw new InvalidOperationException($"Unsupported CIR node kind for tape lowering: {node.Kind}.");+ }+ }++ private sealed class LoweringState+ {+ public List<CirTapeInstruction> Instructions { get; } = new();+ public List<CirTapeBoxPayload> BoxPayloads { get; } = new();+ public List<CirTapeCylinderPayload> CylinderPayloads { get; } = new();+ public List<CirTapeSpherePayload> SpherePayloads { get; } = new();+ public List<CirTapeTransformPayload> TransformPayloads { get; } = new();+ public List<CirTapeTransformEvalPayload> TransformEvalPayloads { get; } = new();+ public int NextSlot { get; private set; }++ public int Emit(CirTapeOpCode opCode, int inputA, int inputB, int payloadIndex, CirNodeKind sourceKind)+ {+ var destSlot = NextSlot++;+ Instructions.Add(new CirTapeInstruction(opCode, destSlot, inputA, inputB, payloadIndex, sourceKind, Instructions.Count));+ return destSlot;+ }+ }+}