Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

8.3 KB
Raw Blame
using System.Collections.Immutable;
using System.Numerics;
using System.Text.Json;
using Aetheris.Cloth3D;

namespace Aetheris.Kernel.Firmament.Tests;

public sealed class ClothQuadSurfaceTests
{
    [Fact]
    public void GrainResponseIsContinuousAndAffineEnergyIsResolutionIndependent()
    {
        var baseline = Patch(3);
        var deformed = Deform(baseline.Positions);
        float energy = Energy(baseline.Compile(), deformed);
        Assert.True(energy > 0);
        var rotated = baseline with { Surface = baseline.Surface! with { GrainRadians = .01f * MathF.PI / 180 } };
        float rotatedEnergy = Energy(rotated.Compile(), deformed);
        Assert.InRange(MathF.Abs(rotatedEnergy / energy - 1), 0, .001f);
        foreach (int side in new[] { 5, 9 })
        {
            var refined = Patch(side);
            Assert.InRange(MathF.Abs(Energy(refined.Compile(), Deform(refined.Positions)) / energy - 1), 0, .0001f);
            var plan = refined.Compile();
            Assert.InRange(MathF.Abs(plan.InverseMasses.Sum(mass => 1 / mass) - .2f), 0, 1e-6f);
        }
        var halfTurn = baseline with { Surface = baseline.Surface! with { GrainRadians = MathF.PI / 2 } };
        Assert.True(MathF.Abs(Energy(halfTurn.Compile(), deformed) / energy - 1) > .1f);
        Assert.DoesNotContain(baseline.Compile().Constraints, item => item.Kind is
            ClothConstraintKind3D.Warp or ClothConstraintKind3D.Weft or ClothConstraintKind3D.Diagonal);
    }

    [Fact]
    public void RenderingDiagonalDoesNotChangeMassesConstraintsOrSolverEvolution()
    {
        var definition = Patch(4);
        var alternate = definition with { Indices = definition.Surface!.Triangulate(true) };
        var first = definition.Compile();
        var second = alternate.Compile();
        Assert.True(first.InverseMasses.SequenceEqual(second.InverseMasses));
        Assert.Equal(first.Constraints.Length, second.Constraints.Length);
        for (int index = 0; index < first.Constraints.Length; index++)
        {
            var a = first.Constraints[index];
            var b = second.Constraints[index];
            Assert.Equal(a.Kind, b.Kind);
            Assert.Equal(a.Compliance, b.Compliance);
            Assert.Equal(a.RestLength, b.RestLength);
            Assert.True(a.Vertices.SequenceEqual(b.Vertices));
            Assert.True(a.Weights.SequenceEqual(b.Weights));
            Assert.True(a.TransverseWeights.SequenceEqual(b.TransverseWeights));
        }
        using var solverA = new ClothSolver3D(first);
        using var solverB = new ClothSolver3D(second);
        solverA.Restore(solverA.Capture() with { Positions = Deform(definition.Positions) });
        solverB.Restore(solverB.Capture() with { Positions = Deform(definition.Positions) });
        for (int tick = 0; tick < 8; tick++)
        {
            solverA.Step(new() { Gravity = Vector3.Zero }, new());
            solverB.Step(new() { Gravity = Vector3.Zero }, new());
        }
        Assert.True(solverA.Capture().Positions.SequenceEqual(solverB.Capture().Positions));
        Assert.True(solverA.Capture().Velocities.SequenceEqual(solverB.Capture().Velocities));
    }

    [Fact]
    public void FittedCurvedRestIsStressFreeAndCommutesWithRigidMotion()
    {
        var definition = Curved();
        var plan = definition.Compile();
        foreach (var constraint in plan.Constraints)
        {
            Assert.InRange(MathF.Abs(ClothSurfaceMechanics3D.Evaluate(constraint, definition.Positions).Residual), 0, 2e-6f);
        }
        var rotation = Quaternion.CreateFromAxisAngle(Vector3.Normalize(new(1, 2, 3)), .8f);
        var moved = definition.Positions.Select(point => Vector3.Transform(point, rotation) + new Vector3(.4f, -.2f, .3f)).ToImmutableArray();
        foreach (var constraint in plan.Constraints)
        {
            Assert.InRange(MathF.Abs(ClothSurfaceMechanics3D.Evaluate(constraint, moved).Residual), 0, 1e-5f);
        }
        using var solver = new ClothSolver3D(plan);
        for (int tick = 0; tick < 8; tick++)
        {
            solver.Step(new() { Gravity = Vector3.Zero }, new());
        }
        float drift = solver.Capture().Positions.Zip(definition.Positions, Vector3.Distance).Max();
        Assert.InRange(drift, 0, 1e-5f);
        var flat = definition with { Surface = definition.Surface! with { Rest = ClothSurfaceRest3D.FlatFabric } };
        Assert.True(Energy(flat.Compile(), definition.Positions) > .01f);
    }

    [Fact]
    public void AnalyticalGradientsMatchFiniteDifferencesForEverySurfaceConstraintKind()
    {
        var definition = Curved();
        var positions = Deform(definition.Positions).SetItem(3, definition.Positions[3] + new Vector3(.01f, .03f, -.02f));
        var plan = definition.Compile();
        foreach (var constraint in plan.Constraints.GroupBy(item => item.Kind).Select(group => group.First()))
        {
            var evaluation = ClothSurfaceMechanics3D.Evaluate(constraint, positions);
            for (int local = 0; local < constraint.Vertices.Length; local++)
            {
                int vertex = constraint.Vertices[local];
                for (int axis = 0; axis < 3; axis++)
                {
                    Vector3 offset = axis switch { 0 => Vector3.UnitX, 1 => Vector3.UnitY, _ => Vector3.UnitZ };
                    const float epsilon = .0001f;
                    float plus = ClothSurfaceMechanics3D.Evaluate(constraint,
                        positions.SetItem(vertex, positions[vertex] + offset * epsilon)).Residual;
                    float minus = ClothSurfaceMechanics3D.Evaluate(constraint,
                        positions.SetItem(vertex, positions[vertex] - offset * epsilon)).Residual;
                    float numeric = (plus - minus) / (2 * epsilon);
                    float analytical = Vector3.Dot(evaluation.Gradients[local], offset);
                    Assert.True(MathF.Abs(numeric - analytical) < .003f,
                        $"{constraint.Kind} vertex {vertex} axis {axis}: analytic {analytical}, numeric {numeric}");
                }
            }
        }
    }

    [Fact]
    public void SurfaceTransportAndInvalidGeometryAreExplicit()
    {
        var definition = Curved();
        var json = new JsonSerializerOptions { IncludeFields = true };
        var restored = JsonSerializer.Deserialize<ClothDefinition3D>(JsonSerializer.Serialize(definition, json), json)!;
        Assert.Equal(definition.Compile().ContentKey, restored.Compile().ContentKey);
        Assert.Throws<ArgumentException>(() => (definition with { OffsetContact = true }).Compile());
        Assert.Throws<ArgumentException>(() => (definition with { Surface = definition.Surface! with { GrainRadians = float.NaN } }).Compile());
        var invalid = definition.Surface!.Quads[0] with { Coordinates = [new(0, 0), new(0, 1), new(1, 1), new(1, 0)] };
        Assert.Throws<ArgumentException>(() => (definition with
        {
            Surface = definition.Surface with { Quads = definition.Surface.Quads.SetItem(0, invalid) },
        }).Compile());
        Assert.Throws<ArgumentException>(() => (definition with { Indices = definition.Indices.SetItem(0, 10) }).Compile());
    }

    private static ClothDefinition3D Patch(int side)
    {
        return ClothQuadSurface3D.Grid("patch", side, side, new(1, 1), Vector3.Zero) with
        {
            Material = new() { WarpCompliance = .001f, WeftCompliance = .004f, DiagonalCompliance = .002f, BendCompliance = .01f },
        };
    }

    private static ClothDefinition3D Curved()
    {
        var definition = Patch(5);
        return definition with
        {
            Positions = definition.Positions.Select(point => point with { Y = .1f * MathF.Sin(MathF.PI * point.X) }).ToImmutableArray(),
            Surface = definition.Surface! with { Rest = ClothSurfaceRest3D.FittedSurface },
        };
    }

    private static ImmutableArray<Vector3> Deform(ImmutableArray<Vector3> positions)
    {
        return positions.Select(point => new Vector3(point.X * 1.1f + .03f * point.Z, point.Y, point.Z * .98f)).ToImmutableArray();
    }

    private static float Energy(CompiledCloth3D plan, ImmutableArray<Vector3> positions)
    {
        return plan.Constraints.Sum(constraint =>
        {
            float residual = ClothSurfaceMechanics3D.Evaluate(constraint, positions).Residual;
            return .5f * residual * residual / constraint.Compliance;
        });
    }
}