Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

8.4 KB
Raw Blame
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Brep.Tessellation;
using Aetheris.Kernel.Core.Geometry;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Step242;

namespace Aetheris.Kernel.Core.Tests.Brep;

public sealed class ConvexStockPrimitiveTests
{
    [Theory]
    [InlineData(4, 4, 6)]
    [InlineData(6, 8, 12)]
    [InlineData(8, 6, 12)]
    [InlineData(12, 20, 30)]
    [InlineData(20, 12, 30)]
    public void RegularStocksAndUniformFilletsHaveClosedSharedTopology(int faces, int vertices, int edges)
    {
        foreach (var radius in new[] { 0d, 1d })
        {
            var result = ConvexStockPrimitives.CreateRegular(faces, 20, radius);
            Assert.True(result.IsSuccess, string.Join("\n", result.Diagnostics));
            var body = result.Value;
            Assert.Equal(radius == 0 ? faces : faces + edges + vertices, body.Topology.Faces.Count());
            if (radius == 0)
            {
                Assert.Equal(vertices, body.Topology.Vertices.Count()); Assert.Equal(edges, body.Topology.Edges.Count());
                foreach (var e in body.Topology.Edges)
                {
                    Assert.True(body.TryGetVertexPoint(e.StartVertexId, out var a)); Assert.True(body.TryGetVertexPoint(e.EndVertexId, out var b));
                    Assert.Equal(20, (a - b).Length, 8);
                }
            }
            else
            {
                Assert.Equal(edges, body.Geometry.Surfaces.Count(s => s.Value.Kind == SurfaceGeometryKind.Cylinder));
                Assert.Equal(vertices, body.Geometry.Surfaces.Count(s => s.Value.Kind == SurfaceGeometryKind.Sphere));
            }
            Check(body);
            var step = Step242Exporter.ExportBody(body);
            Assert.True(step.IsSuccess, string.Join("\n", step.Diagnostics));
            var imported = Step242Importer.ImportBody(step.Value);
            Assert.True(imported.IsSuccess, string.Join("\n", imported.Diagnostics));
            Check(imported.Value);
            Assert.Equal(body.Topology.Faces.Count(), imported.Value.Topology.Faces.Count());
            var mesh = BrepDisplayTessellator.Tessellate(imported.Value);
            Assert.True(mesh.IsSuccess, string.Join("\n", mesh.Diagnostics));
            Assert.Equal(body.Topology.Faces.Count(), mesh.Value.FacePatches.Count(p => p.TriangleIndices.Count > 0));
        }
    }

    [Fact]
    public void WholeBoxRoundingPreservesExtentsAndHasEveryCorner()
    {
        var result = ConvexStockPrimitives.CreateRoundedBox(20, 30, 40, 2);
        Assert.True(result.IsSuccess, string.Join("\n", result.Diagnostics));
        var body = result.Value; Check(body);
        Assert.Equal(26, body.Topology.Faces.Count());
        var points = body.Topology.Vertices.Select(v => { Assert.True(body.TryGetVertexPoint(v.Id, out var p)); return p; }).ToArray();
        Assert.Equal(-10, points.Min(p => p.X), 8); Assert.Equal(10, points.Max(p => p.X), 8);
        Assert.Equal(-15, points.Min(p => p.Y), 8); Assert.Equal(15, points.Max(p => p.Y), 8);
        Assert.Equal(-20, points.Min(p => p.Z), 8); Assert.Equal(20, points.Max(p => p.Z), 8);
        var tooLarge = ConvexStockPrimitives.CreateRoundedBox(20, 30, 40, 10);
        Assert.False(tooLarge.IsSuccess); Assert.Contains(tooLarge.Diagnostics, d => d.Message.StartsWith("UniformFilletRadiusTooLarge:"));
        var mesh = BrepDisplayTessellator.TessellateSurfaceMeshIr(body);
        Assert.True(mesh.IsSuccess, string.Join("\n", mesh.Diagnostics));
        var expected = 16d * 26 * 36 + 4d * (16 * 26 + 26 * 36 + 16 * 36)
            + double.Pi * 4 * (16 + 26 + 36) + 4d / 3 * double.Pi * 8;
        Assert.InRange(SignedMeshVolume(mesh.Value) / expected, .997, 1.001);
    }

    [Theory]
    [InlineData(18, 12, 25)]
    [InlineData(5, 9, 3)]
    [InlineData(10, 10, 10)]
    [InlineData(10, 10, 20)]
    public void EllipsoidIsAnExactQuadricAcrossTheWholeDomainAndStepRoundTrip(double radiusX, double radiusY, double radiusZ)
    {
        var result = EllipsoidPrimitive.Create(radiusX, radiusY, radiusZ); Assert.True(result.IsSuccess);
        var step = Step242Exporter.ExportBody(result.Value); Assert.True(step.IsSuccess, string.Join("\n", step.Diagnostics));
        var import = Step242Importer.ImportBody(step.Value); Assert.True(import.IsSuccess, string.Join("\n", import.Diagnostics));
        foreach (var body in new[] { result.Value, import.Value })
        {
            Check(body);
            foreach (var entry in body.Geometry.Surfaces)
            {
                Assert.True(entry.Value.Kind == SurfaceGeometryKind.Ellipsoid
                    || radiusX == radiusY && radiusY == radiusZ && entry.Value.Kind == SurfaceGeometryKind.Sphere);
                var surface = entry.Value.Ellipsoid?.ToStepPatch();
                if (surface is not null) Assert.NotNull(surface.Weights);
                for (var u = 0; u <= 28; u++) for (var v = 0; v <= 28; v++)
                {
                    var p = surface is not null ? surface.Evaluate(u / 28d, v / 28d) : entry.Value.Sphere!.Value.Evaluate(u / 28d, v / 28d);
                    Assert.Equal(1, p.X * p.X / (radiusX * radiusX) + p.Y * p.Y / (radiusY * radiusY) + p.Z * p.Z / (radiusZ * radiusZ), 11);
                }
            }
            var mesh = BrepDisplayTessellator.Tessellate(body);
            Assert.True(mesh.IsSuccess, string.Join("\n", mesh.Diagnostics));
            Assert.Equal(8, mesh.Value.FacePatches.Count(p => p.TriangleIndices.Count > 0));
            var sharedMesh = BrepDisplayTessellator.TessellateSurfaceMeshIr(body);
            Assert.True(sharedMesh.IsSuccess, string.Join("\n", sharedMesh.Diagnostics));
            Assert.InRange(SignedMeshVolume(sharedMesh.Value) / (4d / 3 * double.Pi * radiusX * radiusY * radiusZ), .995, 1.001);
        }
    }

    [Fact]
    public void EllipsoidRecoveryRequiresItsExactNetAndWorksInARigidFrame()
    {
        var patch = new Aetheris.Kernel.Core.Geometry.Surfaces.EllipsoidSurface(new(13, -5, 7),
            Direction3D.Create(new Vector3D(1, 1, 1)), Direction3D.Create(new Vector3D(1, -1, 0)), 18, 12, 25, true);
        Assert.True(Aetheris.Kernel.Core.Geometry.Surfaces.EllipsoidSurface.TryRecover(patch.ToStepPatch(), out var recovered));
        Assert.Equal(0, (patch.Center - recovered.Center).Length, 8);
        Assert.Equal(18, recovered.RadiusX, 8); Assert.Equal(12, recovered.RadiusY, 8); Assert.Equal(25, recovered.RadiusZ, 8);
        var exact = patch.ToStepPatch(); var altered = exact.ControlPoints.Select(row => row.ToArray()).ToArray();
        altered[1][1] += new Vector3D(.001, 0, 0);
        var freeform = new Aetheris.Kernel.Core.Geometry.Surfaces.BSplineSurfaceWithKnots(2, 2, altered,
            "UNSPECIFIED", false, false, false, [3, 3], [3, 3], [0, 1], [0, 1], "UNSPECIFIED", exact.Weights);
        Assert.False(Aetheris.Kernel.Core.Geometry.Surfaces.EllipsoidSurface.TryRecover(freeform, out _));
    }

    private static double SignedMeshVolume(DisplayTessellationResult mesh)
    {
        var volume = 0d;
        foreach (var patch in mesh.FacePatches)
            for (var i = 0; i < patch.TriangleIndices.Count; i += 3)
            {
                var a = patch.Positions[patch.TriangleIndices[i]] - Point3D.Origin;
                var b = patch.Positions[patch.TriangleIndices[i + 1]] - Point3D.Origin;
                var c = patch.Positions[patch.TriangleIndices[i + 2]] - Point3D.Origin;
                volume += a.Dot(b.Cross(c)) / 6;
            }
        return volume;
    }

    private static void Check(BrepBody body)
    {
        var preflight = BrepExportPreflight.Validate(body);
        Assert.True(preflight.IsValid, string.Join("\n", preflight.Diagnostics));
        foreach (var edge in body.Topology.Edges)
        {
            var uses = body.Topology.Coedges.Where(c => c.EdgeId == edge.Id).ToArray();
            Assert.Equal(2, uses.Length); Assert.NotEqual(uses[0].IsReversed, uses[1].IsReversed);
        }
        foreach (var loop in body.Topology.Loops)
        {
            var uses = loop.CoedgeIds.Select(body.Topology.GetCoedge).ToArray();
            for (var i = 0; i < uses.Length; i++)
            {
                var use = uses[i]; var next = uses[(i + 1) % uses.Length];
                var a = body.Topology.GetEdge(use.EdgeId); var b = body.Topology.GetEdge(next.EdgeId);
                Assert.Equal(use.IsReversed ? a.StartVertexId : a.EndVertexId, next.IsReversed ? b.EndVertexId : b.StartVertexId);
            }
        }
    }
}