Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

17.3 KB
Raw Blame
using System.Text;
using Aetheris.Kernel.Core.Brep.Tessellation;
using Aetheris.Kernel.Core.Math;
using Aetheris.Geometry;
using Aetheris.Surfacing;
using Xunit;

namespace Aetheris.Reconstruction.Tests;

public sealed class ReconstructionTests
{
    [Fact]
    public void Ply_loader_and_validation_preserve_open_boundary_as_evidence()
    {
        using var stream = new MemoryStream(Encoding.ASCII.GetBytes("""
ply
format ascii 1.0
element vertex 4
property float x
property float y
property float z
property float confidence
element face 2
property list uchar int vertex_indices
end_header
0 0 0 1
1 0 0 1
1 1 0 1
0 1 0 1
3 0 1 2
3 0 2 3
"""));
        var mesh = PlyTriangleSurfaceLoader.LoadAscii(stream, "unit-square"); var report = TriangleSurfaceValidator.Validate(mesh);
        Assert.Equal(4, report.VertexCount); Assert.Equal(2, report.TriangleCount); Assert.Equal(4, report.BoundaryEdgeCount); Assert.Equal(1, report.BoundaryLoopCount); Assert.Equal(1, report.ConnectedComponents); Assert.True(report.OrientationConsistent);
    }

    [Fact]
    public void Bvh_returns_nearest_point_and_bounds_candidates_deterministically()
    {
        var mesh = Square(); var bvh = new TriangleBvh(mesh); var hit = bvh.Nearest(new(.25, .25, 2));
        Assert.Equal(2, hit.Distance, 12); Assert.Equal(0, hit.Point.Z); Assert.Contains(hit.TriangleIndex, bvh.Query(new(new(0, 0, -.1), new(.6, .6, .1))));
    }

    [Fact]
    public void Recovery_builds_bounded_second_jet_panels_and_quad_mesh()
    {
        var mesh = Grid(5); var (field, summary) = StructuredSurfaceRecovery.EstimateField(mesh); var charts = StructuredSurfaceRecovery.BuildCharts(mesh, field, spatialBins: 1, minimumFaces: 2); var output = PanelSurfaceMeshLowering.Lower(charts, 3);
        var chart = Assert.Single(charts.Charts); Assert.Equal("Accepted", chart.Status); Assert.True(chart.Patch.SupportsSecondJet); Assert.True(chart.Patch.EvaluateJet2(.5, .5).IsRegular); Assert.Equal(9, output.Quads.Count); Assert.Equal(0, output.TriangleCount); Assert.Equal(summary.SampleCount, summary.KnownDirectionCount);
        var panel = RecoveredPanelMaterializer.Materialize(chart); Assert.True(panel.IsSuccess); Assert.NotNull(panel.Panel);
    }

    [Fact]
    public void Recovery_hash_is_stable()
    {
        var mesh = Grid(4); var a = Run(mesh); var b = Run(mesh); Assert.Equal(a.DeterministicHash, b.DeterministicHash);
        static StructuredSurfaceMesh Run(TriangleSurfaceMesh m) { var (f, _) = StructuredSurfaceRecovery.EstimateField(m); return PanelSurfaceMeshLowering.Lower(StructuredSurfaceRecovery.BuildCharts(m, f, 1, 2), 4); }
    }

    [Fact]
    public void Two_chart_fixture_has_one_internal_seam_authority_with_opposite_side_orientation()
    {
        var mesh = Square();
        var network = RecoveredSeamNetworkBuilder.Build(mesh, ["chart-a", "chart-b"]);
        var seam = Assert.Single(network.Seams, item => item.Classification == RecoveredSeamClassification.Internal);

        Assert.Equal("chart-a", seam.ChartA);
        Assert.Equal("chart-b", seam.ChartB);
        Assert.Equal(RecoveredSeamOrientation.SameDirection, seam.LeftOrientation);
        Assert.Equal(RecoveredSeamOrientation.ReversedDirection, seam.RightOrientation);
        Assert.Equal(0, seam.G0Residual);
        Assert.Equal(0, seam.ParameterStart);
        Assert.Equal(1, seam.ParameterEnd);
        Assert.Equal(2, network.Junctions.Count);
        Assert.All(network.Junctions, junction => Assert.Contains(seam.StableId, junction.IncidentSeamIds));
    }

    [Fact]
    public void Source_open_boundary_is_retained_and_is_not_an_internal_crack()
    {
        var mesh = Square(); var (field, _) = StructuredSurfaceRecovery.EstimateField(mesh);
        var charts = StructuredSurfaceRecovery.BuildCharts(mesh, field, spatialBins: 1, minimumFaces: 1);
        var canonical = SeamAuthoritativeSurfaceMeshLowering.Lower(mesh, charts);

        Assert.Equal(0, canonical.InternalCrackGroups);
        Assert.Equal(1, canonical.IntentionalOpenBoundaryLoops);
        Assert.Equal(4, canonical.BoundaryEdgeCount);
        Assert.Equal(0, canonical.NonManifoldEdgeCount);
        Assert.Equal(1, canonical.QuadCount);
        Assert.Equal(0, canonical.TriangleCount);
        Assert.Equal("Pass", canonical.ValidationStatus);
        Assert.True(SurfaceMeshIrValidator.TryValidate(canonical.Document, out _));
        Assert.All(charts.Seams, seam => Assert.Equal(RecoveredSeamClassification.SourceOpenBoundary, seam.Classification));
    }

    [Fact]
    public void Seam_judgment_rejects_line_when_bounded_residual_is_exceeded_and_is_stable()
    {
        var vertices = new Point3D[]
        {
            new(0,0,0), new(1,0,0), new(2,0,0),
            new(0,1,0), new(1,1,.2), new(2,1,0),
            new(0,2,0), new(1,2,0), new(2,2,0)
        };
        var triangles = new Triangle[]
        {
            new(0,1,4), new(0,4,3), new(3,4,7), new(3,7,6),
            new(1,2,5), new(1,5,4), new(4,5,8), new(4,8,7)
        };
        var mesh = new TriangleSurfaceMesh(vertices, triangles, null, "bent-two-chart", "fixture", new Dictionary<string,string>());
        var labels = new[] { "left", "left", "left", "left", "right", "right", "right", "right" };
        var first = RecoveredSeamNetworkBuilder.Build(mesh, labels);
        var second = RecoveredSeamNetworkBuilder.Build(mesh, labels);
        var seam = Assert.Single(first.Seams, item => item.Classification == RecoveredSeamClassification.Internal);

        Assert.Equal(RecoveredSeamRepresentation.NonRationalBSpline, seam.RepresentationKind);
        Assert.Equal("NonRationalBSpline", seam.JudgmentWinner);
        Assert.False(seam.JudgmentCandidates.Single(candidate => candidate.Representation == "Line").Admissible);
        Assert.Equal(seam.StableId, second.Seams.Single(item => item.Classification == RecoveredSeamClassification.Internal).StableId);
        Assert.Equal(seam.JudgmentWinner, second.Seams.Single(item => item.StableId == seam.StableId).JudgmentWinner);
    }

    [Fact]
    public void Quad_atlas_square_has_four_authoritative_sides_and_strict_panel()
    {
        var mesh = Square(); var (field, _) = StructuredSurfaceRecovery.EstimateField(mesh);
        var atlas = QuadAtlasRecovery.Build(mesh, field); var chart = Assert.Single(atlas.Charts);

        Assert.Empty(atlas.UnresolvedTriangles);
        Assert.Equal(4, chart.OrderedSides.Count);
        Assert.Equal(4, chart.CornerVertices.Count);
        Assert.True(PanelConcept.Validate(chart.StrictPanel).Satisfies);
        Assert.All(chart.OrderedSides, use => Assert.Equal(use.SeamId, chart.StrictPanel[use.Side.ToString()].SourceCurveStableId));
        Assert.Single(atlas.OpenBoundaryLoops);
        Assert.Equal(0, atlas.UnintendedBoundaryLoops);
        Assert.True(atlas.IsGloballyValid);
    }

    [Fact]
    public void Quad_atlas_preserves_intentional_hole()
    {
        var mesh = Ring(); var report = TriangleSurfaceValidator.Validate(mesh); var (field, _) = StructuredSurfaceRecovery.EstimateField(mesh);
        var atlas = QuadAtlasRecovery.Build(mesh, field);

        Assert.Equal(2, report.BoundaryLoopCount);
        Assert.Equal(2, atlas.OpenBoundaryLoops.Count);
        Assert.All(atlas.Seams.Where(s => s.IsSourceBoundary), s => Assert.Single(s.ChartUses));
        Assert.All(atlas.Charts, c => Assert.Equal(4, c.OrderedSides.Count));
    }

    [Fact]
    public void Ambiguous_quad_routing_uses_stable_judgment_winner_after_hard_topology_filter()
    {
        var mesh = Grid(4); var (field, _) = StructuredSurfaceRecovery.EstimateField(mesh);
        var first = QuadAtlasRecovery.Build(mesh, field); var second = QuadAtlasRecovery.Build(mesh, field);

        Assert.NotEmpty(first.JudgmentTraces);
        Assert.All(first.JudgmentTraces, t => Assert.InRange(t.TopCandidates.Count, 1, 3));
        Assert.Equal(first.DeterministicHash, second.DeterministicHash);
        Assert.Equal(first.JudgmentTraces.Select(t => t.Winner), second.JudgmentTraces.Select(t => t.Winner));
    }

    [Fact]
    public void Quarter_turn_fixture_recovers_extraordinary_singularity_and_four_sided_charts()
    {
        var mesh = Fan(); var directions = new[] { 0d, 22.5, 45, 67.5 }.Select(x => x * Math.PI / 180).ToArray();
        var field = Enumerable.Range(0, 4).Select(i =>
        {
            var t = mesh.Triangles[i]; var a = mesh.Vertices[t.A]; var b = mesh.Vertices[t.B]; var c = mesh.Vertices[t.C];
            return new DifferentialSample(i, new((a.X+b.X+c.X)/3,(a.Y+b.Y+c.Y)/3,0), new(0,0,1),
                new(Math.Cos(directions[i]),Math.Sin(directions[i]),0), new(Math.Cos(directions[i]),Math.Sin(directions[i]),0), 0, 1, true, "fixture");
        }).ToArray();
        var atlas = QuadAtlasRecovery.Build(mesh, field);

        var singularity = Assert.Single(atlas.Singularities, s => s.SourceVertices.Contains(0));
        Assert.Equal(.25, singularity.QuarterIndex, 12);
        Assert.Equal(3, singularity.ImpliedQuadValence);
        Assert.Equal(2, atlas.Charts.Count);
        Assert.All(atlas.Charts, chart => Assert.Equal(4, chart.OrderedSides.Count));
    }

    [Fact]
    public void Offset_field_moves_position_and_its_gradient_corrects_geometric_normal()
    {
        var patch = PlanePatch("base"); var values = new double[3, 3]; values[1, 1] = .2;
        var residual = new SurfaceResidualField("offset", patch.StableId, patch.Domain, new(values, patch.Domain), null,
            ResidualSeamPolicy.ZeroAtBoundary, Evidence("synthetic known displacement"));

        var sample = residual.Evaluate(patch, .5, .5);

        Assert.Equal(.2, sample.Point.Z, 12); Assert.True(sample.PositionWasDisplaced); Assert.False(sample.NormalCorrectionWasApplied);
        Assert.InRange((sample.GeometricNormal - new Vector3D(0, 0, 1)).Length, 0, 1e-10); // symmetric peak has zero center gradient
        Assert.NotEqual(new Vector3D(0, 0, 1), residual.Evaluate(patch, .25, .5).GeometricNormal);
    }

    [Fact]
    public void Normal_only_field_never_moves_geometry()
    {
        var patch = PlanePatch("normal-base"); var normals = new Vector3D[2, 2];
        for (var i = 0; i < 2; i++) for (var j = 0; j < 2; j++) normals[i, j] = new(0, .2, 1);
        var residual = new SurfaceResidualField("normal", patch.StableId, patch.Domain, null, new(normals, patch.Domain),
            ResidualSeamPolicy.SharedBoundarySamples, Evidence("synthetic normal-only detail"));

        var sample = residual.Evaluate(patch, .37, .61);

        Assert.Equal(patch.EvaluatePoint(.37, .61), sample.Point); Assert.False(sample.PositionWasDisplaced);
        Assert.Equal(new Vector3D(0, 0, 1), sample.GeometricNormal); Assert.NotEqual(sample.GeometricNormal, sample.InterpretedNormal);
    }

    [Fact]
    public void Residual_decomposition_keeps_tangential_error_explicit()
    {
        var patch = PlanePatch("decompose"); var normal = SurfaceResidualExtractor.Decompose(new(.5, .5, .1), new(0, 0, 1), patch);
        var tangential = SurfaceResidualExtractor.Decompose(new(1.1, .5, .1), new(0, 0, 1), patch);

        Assert.Equal(.1, normal.NormalComponent, 6); Assert.InRange(normal.TangentialMagnitude, 0, 1e-5); Assert.True(SurfaceResidualExtractor.IsScalarOffsetSuitable(normal));
        Assert.True(tangential.TangentialMagnitude > .09); Assert.False(SurfaceResidualExtractor.IsScalarOffsetSuitable(tangential));
    }

    [Fact]
    public void Quad_atlas_lowering_uses_native_bounded_patch_support_without_plane_proxy()
    {
        var mesh = Grid(3); var (field, _) = StructuredSurfaceRecovery.EstimateField(mesh); var atlas = QuadAtlasRecovery.Build(mesh, field);
        var canonical = QuadAtlasSurfaceMeshLowering.Lower(mesh, atlas);

        Assert.All(canonical.Document.Patches.Where(p => p.ChartId!.StartsWith("quad-")), p =>
        {
            Assert.Equal(SurfaceMeshSupportKind.BoundedParametricPatch, p.Support.Kind); Assert.NotNull(p.Support.BoundedPatch); Assert.Contains("no plane proxy", p.PlanarPlannerPath);
        });
        Assert.Equal(0, canonical.InternalCrackGroups); Assert.Equal("Pass", canonical.ValidationStatus);
        var obj = SurfaceMeshObjExporter.Export(canonical.Document); Assert.Equal(canonical.QuadCount, obj.QuadCount);
    }

    [Fact]
    public void Reconciled_zero_boundary_residuals_keep_neighboring_panels_crack_free()
    {
        var mesh = Grid(3); var (field, _) = StructuredSurfaceRecovery.EstimateField(mesh); var atlas = QuadAtlasRecovery.Build(mesh, field);
        var fields = atlas.Charts.ToDictionary(chart => chart.StableId, chart =>
            new SurfaceResidualField("residual-" + chart.StableId, chart.StrictPanel.AuthoredPatch.StableId, chart.StrictPanel.AuthoredPatch.Domain,
                new(new double[2, 2], chart.StrictPanel.AuthoredPatch.Domain), null, ResidualSeamPolicy.ZeroAtBoundary, Evidence("zero seam fixture")));

        var canonical = QuadAtlasSurfaceMeshLowering.Lower(mesh, atlas, fields);

        Assert.Equal(0, canonical.InternalCrackGroups); Assert.Equal("Pass", canonical.ValidationStatus);
        Assert.All(canonical.Document.Patches, patch => Assert.NotNull(patch.ResidualFieldId));
    }

    [Fact]
    public void Global_matching_finds_augmenting_reroute_that_local_greedy_pairing_misses()
    {
        var edges = new[] { new GlobalMatchingEdge(0, 1, 10, "greedy"), new(0, 2, 5, "left"), new(1, 3, 5, "right") };
        var result = GlobalQuadLayoutMatcher.Match(4, edges, new[] { 1, 0, -1, -1 });

        Assert.Equal(2, result.MatchedEdges); Assert.Equal(2, result.Mate[0]); Assert.Equal(3, result.Mate[1]); Assert.Equal(1, result.Augmentations);
    }

    [Fact]
    public void Smooth_tiny_quad_panels_coarsen_under_bounded_structural_merge()
    {
        var mesh = Grid(4); var (field, _) = StructuredSurfaceRecovery.EstimateField(mesh); var atlas = QuadAtlasRecovery.Build(mesh, field);
        var result = StructuralPanelCoarsener.Coarsen(mesh, atlas);

        Assert.True(result.Panels.Count < atlas.Charts.Count, $"merged={result.MergedPairCount} topo={result.RejectedTopology} feature={result.RejectedFeature} uv={result.RejectedParameterization} residual={result.RejectedResidual}"); Assert.True(result.MergedPairCount > 0); Assert.True(result.MergeRatio > 1);
        Assert.All(result.Panels, panel => Assert.True(PanelConcept.Validate(panel.Panel).Satisfies));
    }

    [Fact]
    public void Hard_crease_evidence_rejects_cross_feature_merge()
    {
        var mesh = CreasedGrid(); var (field, _) = StructuredSurfaceRecovery.EstimateField(mesh); var atlas = QuadAtlasRecovery.Build(mesh, field);
        var result = StructuralPanelCoarsener.Coarsen(mesh, atlas, new(MaximumFeatureAngleDegrees: 5));

        Assert.All(result.Panels.Where(panel => panel.SourceChartIds.Count > 1), panel => Assert.InRange(panel.NormalDiscontinuityDegrees, 0, 5));
    }

    [Fact]
    public void Cross_field_regularization_is_deterministic_and_preserves_detected_global_index()
    {
        var mesh = Grid(4); var (field, _) = StructuredSurfaceRecovery.EstimateField(mesh);
        var first = CrossFieldRegularizer.Regularize(mesh, field, 3); var second = CrossFieldRegularizer.Regularize(mesh, field, 3);

        Assert.True(first.Report.GlobalIndexPreserved); Assert.True(first.Report.OutputSingularities <= first.Report.InputSingularities);
        Assert.Equal(first.Report, second.Report); Assert.Equal(first.Field.Select(x => x.CrossDirection), second.Field.Select(x => x.CrossDirection));
    }

    private static ResidualFieldEvidence Evidence(string method) => new(PredicateEvidenceKind.Sampled, "fixture", method, 0, 0, 0, 0, 9);
    private static BoundedParametricPatch3 PlanePatch(string id) => BoundedParametricPatch3.Procedural(id,
        new(new(0, 1), new(0, 1)), (u, v) => new(new(u, v, 0), new(1, 0, 0), new(0, 1, 0), Direction3D.Create(new(0, 0, 1)), false), "fixture");

    private static TriangleSurfaceMesh Square() => new([new(0, 0, 0), new(1, 0, 0), new(1, 1, 0), new(0, 1, 0)], [new(0, 1, 2), new(0, 2, 3)], null, "square", "fixture", new Dictionary<string, string>());
    private static TriangleSurfaceMesh Grid(int n)
    {
        var p = new List<Point3D>(); for (var j = 0; j < n; j++) for (var i = 0; i < n; i++) p.Add(new(i / (double)(n - 1), j / (double)(n - 1), .02 * i * j)); var t = new List<Triangle>(); for (var j = 0; j < n - 1; j++) for (var i = 0; i < n - 1; i++) { var a = j * n + i; t.Add(new(a, a + 1, a + n + 1)); t.Add(new(a, a + n + 1, a + n)); } return new(p, t, null, "grid", "fixture", new Dictionary<string, string>());
    }
    private static TriangleSurfaceMesh CreasedGrid()
    {
        var p = new List<Point3D>(); for (var j = 0; j < 3; j++) for (var i = 0; i < 3; i++) p.Add(new(i, j, i < 2 ? 0 : 1));
        var t = new List<Triangle>(); for (var j = 0; j < 2; j++) for (var i = 0; i < 2; i++) { var a = j * 3 + i; t.Add(new(a, a + 1, a + 4)); t.Add(new(a, a + 4, a + 3)); }
        return new(p, t, null, "creased-grid", "fixture", new Dictionary<string, string>());
    }

    private static TriangleSurfaceMesh Ring()
    {
        var p = new Point3D[] { new(0,0,0),new(3,0,0),new(3,3,0),new(0,3,0),new(1,1,0),new(2,1,0),new(2,2,0),new(1,2,0) };
        var t = new Triangle[] { new(0,1,5),new(0,5,4),new(1,2,6),new(1,6,5),new(2,3,7),new(2,7,6),new(3,0,4),new(3,4,7) };
        return new(p,t,null,"ring","fixture",new Dictionary<string,string>());
    }
    private static TriangleSurfaceMesh Fan() => new(
        [new(0,0,0),new(1,0,0),new(0,1,0),new(-1,0,0),new(0,-1,0)],
        [new(0,1,2),new(0,2,3),new(0,3,4),new(0,4,1)],null,"quarter-turn-fan","fixture",new Dictionary<string,string>());
}