Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

7.5 KB
Raw Blame
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Brep.Tessellation;
using Aetheris.Kernel.Core.Diagnostics;
using Aetheris.Kernel.Core.Step242;
using System.Text;

namespace Aetheris.Kernel.Core.Tests.Step242;

public sealed class Step242HoleSemanticsTests
{
    [Fact]
    public void ImportBody_PlanarFaceWithHole_ImportsAndPreservesMultipleLoops()
    {
        var import = Step242Importer.ImportBody(Step242FixtureCorpus.PlanarFaceWithRectangularHole);

        Assert.True(import.IsSuccess);
        var body = import.Value;

        var validation = BrepBindingValidator.Validate(body, requireAllEdgeAndFaceBindings: true);
        Assert.True(validation.IsSuccess);

        var face = Assert.Single(body.Topology.Faces);
        Assert.True(face.LoopIds.Count >= 2);

        var tessellationException = Record.Exception(() => BrepDisplayTessellator.Tessellate(body));
        Assert.Null(tessellationException);
    }

    [Fact]
    public void ImportBody_MultiLoopPlanarEqualAreas_ReturnsAmbiguousOuterValidationFailure()
    {
        var import = Step242Importer.ImportBody(Step242FixtureCorpus.PlanarFaceEqualAreaLoops);

        Assert.False(import.IsSuccess);
        var diagnostic = Assert.Single(import.Diagnostics);
        Assert.Equal(KernelDiagnosticCode.ValidationFailed, diagnostic.Code);
        Assert.Equal("Importer.LoopRole.AmbiguousOuter", diagnostic.Source);
    }

    [Fact]
    public void ImportBody_MultiLoopPlanarInnerOutside_ReturnsInnerDisjointAfterNormalizationValidationFailure()
    {
        var import = Step242Importer.ImportBody(Step242FixtureCorpus.PlanarFaceInnerOutsideOuter);

        Assert.False(import.IsSuccess);
        var diagnostic = Assert.Single(import.Diagnostics);
        Assert.Equal(KernelDiagnosticCode.ValidationFailed, diagnostic.Code);
        Assert.Equal("Importer.LoopRole.InnerDisjointAfterNormalization", diagnostic.Source);
        Assert.StartsWith("Inner loop could not be normalized: disjoint.", diagnostic.Message, StringComparison.Ordinal);
    }


    [Fact]
    public void ImportBody_ManyPlanarSingleEdgeCircularHoles_ClassifiesDeterministically()
    {
        var parsed = Step242SubsetParser.Parse(Step242FixtureCorpus.PlanarFaceManyCircularSingleEdgeHolesScrambledBounds);
        Assert.True(parsed.IsSuccess);
        var advancedFace = parsed.Value.TryGetEntity(3, "ADVANCED_FACE");
        Assert.True(advancedFace.IsSuccess);
        var declaredBounds = Step242SubsetDecoder.ReadAdvancedFaceBounds(advancedFace.Value, 0, "test bounds");
        Assert.True(declaredBounds.IsSuccess);
        Assert.Equal(4, declaredBounds.Value.Count);

        var direct = Step242Importer.ImportExactBrepCore(parsed.Value);
        Assert.True(direct.IsSuccess);
        Assert.Equal(4, Assert.Single(direct.Value.Topology.Faces).LoopIds.Count);

        var first = Step242Importer.ImportBody(Step242FixtureCorpus.PlanarFaceManyCircularSingleEdgeHolesScrambledBounds);
        var second = Step242Importer.ImportBody(Step242FixtureCorpus.PlanarFaceManyCircularSingleEdgeHolesScrambledBounds);

        Assert.True(first.IsSuccess);
        Assert.True(second.IsSuccess);

        var firstFace = Assert.Single(first.Value.Topology.Faces);
        var secondFace = Assert.Single(second.Value.Topology.Faces);

        Assert.Equal(4, firstFace.LoopIds.Count);
        Assert.Equal(firstFace.LoopIds.Select(l => l.Value), secondFace.LoopIds.Select(l => l.Value));

        // Declared STEP traversal is authoritative. The importer validates
        // geometry without rewriting a source face's bound ordering.
        Assert.Equal([1, 2, 3, 4], firstFace.LoopIds.Select(loopId => loopId.Value));
    }

    [Fact]
    public void ImportBody_MultiLoopSphericalFace_ReturnsUnsupportedSurfaceForHolesValidationFailure()
    {
        var import = Step242Importer.ImportBody(Step242FixtureCorpus.SphericalFaceWithTwoLoops);

        Assert.False(import.IsSuccess);
        var diagnostic = Assert.Single(import.Diagnostics);
        Assert.Equal(KernelDiagnosticCode.ValidationFailed, diagnostic.Code);
        Assert.Equal("Importer.LoopRole.UnsupportedSurfaceForHoles.Sphere", diagnostic.Source);
    }

    [Fact]
    public void ImportBody_MultiLoopCylindricalFace_Imports_ThenTessellatesDeterministically()
    {
        var import = Step242Importer.ImportBody(Step242FixtureCorpus.CylindricalFaceWithTwoLoops);

        Assert.True(import.IsSuccess);
        Assert.Contains(import.Diagnostics, diagnostic =>
            diagnostic.Source == "Importer.StepOrientation.GlobalOrientationUnknown");

        var body = import.Value;
        var validation = BrepBindingValidator.Validate(body, requireAllEdgeAndFaceBindings: true);
        Assert.True(validation.IsSuccess);

        var cylindricalFace = Assert.Single(body.Topology.Faces);
        Assert.Equal(2, cylindricalFace.LoopIds.Count);

        var tessellation = BrepDisplayTessellator.Tessellate(body);
        Assert.True(tessellation.IsSuccess);

        var diagnostic = Assert.Single(tessellation.Diagnostics);
        Assert.Equal(KernelDiagnosticCode.ValidationFailed, diagnostic.Code);
        Assert.Equal("Viewer.Tessellation.TrimEvaluationFailed", diagnostic.Source);
        Assert.StartsWith(
            $"Face {cylindricalFace.Id.Value} cylinder trim evaluation failed; skipping face patch",
            diagnostic.Message,
            StringComparison.Ordinal);

        var patch = Assert.Single(tessellation.Value.FacePatches);
        Assert.Equal(cylindricalFace.Id, patch.FaceId);
        Assert.Empty(patch.Positions);
        Assert.Empty(patch.Normals);
        Assert.Empty(patch.TriangleIndices);
    }

    [Fact]
    public void ImportBody_OcctNutExtractPlanarMultiBound_ImportsAfterBoundedRecovery()
    {
        var import = Step242Importer.ImportBody(ReadNutExtractStepText());

        Assert.True(import.IsSuccess, string.Join(Environment.NewLine, import.Diagnostics.Select(d => d.Message)));
        var body = import.Value;
        var validation = BrepBindingValidator.Validate(body, requireAllEdgeAndFaceBindings: true);
        Assert.True(validation.IsSuccess, string.Join(Environment.NewLine, validation.Diagnostics.Select(d => d.Message)));
    }

    [Fact]
    public void ImportBody_OcctNutExtractUsesWeightedCurveGeometryWithoutPlanarCrossingRepair()
    {
        var diagnostics = new List<Step242Importer.PlanarMultiBoundJudgmentDiagnostic>();
        using var scope = Step242Importer.CapturePlanarMultiBoundJudgmentDiagnostics(diagnostics);

        var import = Step242Importer.ImportBody(ReadNutExtractStepText());

        Assert.True(import.IsSuccess, string.Join(Environment.NewLine, import.Diagnostics.Select(d => d.Message)));
        // The source's weighted curves are now evaluated and recovered as geometry. The previous
        // planar-crossing judgment was needed only when these weights were silently discarded.
        Assert.DoesNotContain(diagnostics, d => d.SelectedCandidate == "planar_crossing_inside_recover_as_inner");
        Assert.Contains(import.Value.Geometry.Curves, pair => pair.Value.RecoveryProvenance is not null);
    }

    private static string ReadNutExtractStepText()
    {
        var fullPath = Path.GetFullPath(
            Path.Combine(
                AppContext.BaseDirectory,
                "..",
                "..",
                "..",
                "..",
                "fixtures", "Compatibility", "Firmasm", "LegacyAssembly", "examples",
                "occt-nut-bolt",
                "_nut_extract.step"));
        return File.ReadAllText(fullPath, Encoding.UTF8);
    }
}