Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

17.2 KB
Raw Blame
using Aetheris.Kernel.Firmament.FirmamentV2;
using Aetheris.Kernel.Core.Brep.Tessellation;
using System.Diagnostics;
using System.Text.Json;

namespace Aetheris.Kernel.Firmament.Tests;

public sealed class FirmamentPerforationTests
{
    private const string GridSource = """
        Model PerforatedPanel {
          Units: mm
          Box Body { Size: [30mm, 30mm, 2mm] }
          Modify Body {
            Perforation Vent {
              On: +Z
              Diameter: 6mm
              Layout: Grid
              Pitch: 12mm
              Margin: 3mm
            }
          }
        }
        """;

    private const string CylindricalSource = """
        Struct PerforatedSleeve {
          Cylinder<Hollow> Body {
            Radius: 56mm
            Height: 142mm
            WallThickness: 0.8mm
            Openings: [Top]
          }
          Modify Body {
            Perforation Vents {
              On: OuterWall
              Diameter: 9mm
              Layout: CylindricalGrid
              Pitch: 15mm
              CircumferentialPitch: 18mm
              MarginTop: 12mm
              MarginBottom: 20mm
              MinimumLigament: 2mm
              StartAngle: 9deg
            }
          }
        }
        """;

    [Fact]
    public void Grid_BuildsManifoldStepAndPerInstanceWallCorrespondence()
    {
        var built = FirmamentBuildAndExport.CompileSource(GridSource);
        Assert.True(built.IsSuccess, string.Join(" | ", built.Diagnostics.Select(d => d.Message)));
        var report = Assert.IsType<FirmamentPerforationReport>(built.Value.Perforation);
        Assert.Equal(4, report.InstanceCount);
        Assert.True(report.Manifold && report.StepReimportedManifold);
        Assert.Equal(4, built.Value.RuntimeCorrespondence!.Descendants.Count);
        Assert.All(built.Value.RuntimeCorrespondence.Descendants, descendant =>
        {
            Assert.NotNull(descendant.Face);
            Assert.Equal("Body.Vent", descendant.ParentStableId);
        });
        Assert.Contains("Body.Vent", built.Value.RuntimeCorrespondence.SourceSpans!.Keys);
        Assert.Equal("Body.Vent.Row0.Col0", report.InstanceIds[0]);
        Assert.NotEmpty(built.Value.StepText);
    }

    [Fact]
    public void Hex_StaggersRowsAndClipsFullOpenings()
    {
        var parsed = FirmamentV2Parser.Parse(GridSource.Replace("Layout: Grid", "Layout: Hex", StringComparison.Ordinal));
        Assert.True(parsed.IsSuccess, string.Join(" | ", parsed.Diagnostics));
        var feature = Assert.Single(Assert.Single(parsed.Document!.ModifyBlocks!).Perforations!);
        var plan = FirmamentPerforationPlanner.Plan(30, 30, feature);
        Assert.True(plan.Succeeded, plan.Diagnostic);
        Assert.Equal(-6, plan.Instances[0].X, 8);
        Assert.Equal(0, plan.Instances.First(i => i.Row == 1).X, 8);
        Assert.All(plan.Instances, instance =>
        {
            Assert.InRange(instance.X, -9, 9);
            Assert.InRange(instance.Y, -9, 9);
        });
    }

    [Fact]
    public void CylindricalPlanner_WrapsWithoutDuplicateAndKeepsStableGridIdentity()
    {
        var parsed = FirmamentV2Parser.Parse(CylindricalSource);
        Assert.True(parsed.IsSuccess, string.Join(" | ", parsed.Diagnostics));
        var feature = Assert.Single(Assert.Single(parsed.Document!.ModifyBlocks!).Perforations!);
        var plan = FirmamentCylindricalPerforationPlanner.Plan(56, 142, 0.8, feature);
        Assert.True(plan.Succeeded, plan.Diagnostic);
        Assert.Equal(plan.Rows * plan.Columns, plan.Instances.Count);
        Assert.Equal(plan.Instances.Count, plan.Instances.Select(instance => instance.StableId("Body.Vents")).Distinct().Count());
        Assert.All(plan.Instances, instance => Assert.InRange(instance.AngleRadians, 0, 2 * Math.PI));
        Assert.All(plan.Instances, instance => Assert.InRange(instance.Z, 20 + 4.5, 142 - 12 - 4.5));
        Assert.Equal(2 * Math.PI / plan.Columns, plan.AngularPitchRadians, 10);
        Assert.Equal("Body.Vents.Row0.Col0", plan.Instances[0].StableId("Body.Vents"));
        var again = FirmamentCylindricalPerforationPlanner.Plan(56, 142, 0.8, feature);
        Assert.Equal(plan.Instances, again.Instances);
        var wrappedPhase = FirmamentCylindricalPerforationPlanner.Plan(56, 142, 0.8,
            feature with { StartAngleDegrees = feature.StartAngleDegrees + 360 });
        Assert.Equal(plan.Instances, wrappedPhase.Instances);
    }

    [Fact]
    public void CylindricalPlanner_StaggerAndInvalidClearanceAreDeterministic()
    {
        var parsed = FirmamentV2Parser.Parse(CylindricalSource.Replace("CylindricalGrid", "CylindricalStaggered", StringComparison.Ordinal));
        Assert.True(parsed.IsSuccess, string.Join(" | ", parsed.Diagnostics));
        var feature = Assert.Single(Assert.Single(parsed.Document!.ModifyBlocks!).Perforations!);
        var plan = FirmamentCylindricalPerforationPlanner.Plan(56, 142, 0.8, feature);
        Assert.True(plan.Succeeded, plan.Diagnostic);
        Assert.Equal(plan.AngularPitchRadians / 2, plan.Instances[plan.Columns].AngleRadians - plan.Instances[0].AngleRadians, 10);
        Assert.Equal("perforation-hole-overlap", FirmamentCylindricalPerforationPlanner.Plan(56, 142, 0.8,
            feature with { Pitch = 9 }).Diagnostic);
        Assert.Equal("perforation-no-admissible-holes", FirmamentCylindricalPerforationPlanner.Plan(56, 142, 0.8,
            feature with { MarginTop = 75, MarginBottom = 75 }).Diagnostic);
        Assert.Equal("perforation-hole-overlap", FirmamentCylindricalPerforationPlanner.Plan(56, 142, 0.8,
            feature with { CircumferentialPitch = 9 }).Diagnostic);
        Assert.Equal("perforation-cylindrical-tangent-or-oversize", FirmamentCylindricalPerforationPlanner.Plan(56, 142, 0.8,
            feature with { Diameter = 111 }).Diagnostic);
        Assert.Equal("perforation-cylindrical-offset-unsupported", FirmamentCylindricalPerforationPlanner.Plan(56, 142, 0.8,
            feature with { OffsetX = 1 }).Diagnostic);
    }

    [Fact]
    public void CylindricalPlanner_ParameterEditsRetainPatternCoordinates()
    {
        var parsed = FirmamentV2Parser.Parse(CylindricalSource);
        var feature = Assert.Single(Assert.Single(parsed.Document!.ModifyBlocks!).Perforations!);
        var original = FirmamentCylindricalPerforationPlanner.Plan(56, 142, 0.8, feature);
        var smallerHole = FirmamentCylindricalPerforationPlanner.Plan(56, 142, 0.8, feature with { Diameter = 8 });
        var thickerWall = FirmamentCylindricalPerforationPlanner.Plan(56, 142, 1.2, feature);
        Assert.True(smallerHole.Succeeded && thickerWall.Succeeded);
        Assert.Equal(original.Instances.Select(i => (i.Row, i.Column)),
            smallerHole.Instances.Select(i => (i.Row, i.Column)));
        Assert.Equal(original.Instances.Select(i => (i.Row, i.Column)),
            thickerWall.Instances.Select(i => (i.Row, i.Column)));
    }

    [Fact]
    public void CylindricalPerforation_DiameterAndThicknessEditsRebuildStep()
    {
        var diameter = FirmamentBuildAndExport.CompileSource(CylindricalSource.Replace("Diameter: 9mm", "Diameter: 8mm", StringComparison.Ordinal));
        var thickness = FirmamentBuildAndExport.CompileSource(CylindricalSource.Replace("WallThickness: 0.8mm", "WallThickness: 1.2mm", StringComparison.Ordinal));
        Assert.True(diameter.IsSuccess, string.Join(" | ", diameter.Diagnostics.Select(d => d.Message)));
        Assert.True(thickness.IsSuccess, string.Join(" | ", thickness.Diagnostics.Select(d => d.Message)));
        Assert.Equal(133, diameter.Value.Perforation!.InstanceCount);
        Assert.Equal(133, thickness.Value.Perforation!.InstanceCount);
        Assert.NotEqual(diameter.Value.Perforation.StepSha256, thickness.Value.Perforation.StepSha256);
        Assert.Equal(diameter.Value.Perforation.InstanceIds, thickness.Value.Perforation.InstanceIds);
    }

    [Fact]
    public void CylindricalPerforation_ExportsOneManifoldPatternWithStableWalls()
    {
        var buildStart = Stopwatch.GetTimestamp();
        var built = FirmamentBuildAndExport.CompileSource(CylindricalSource);
        var buildMilliseconds = Stopwatch.GetElapsedTime(buildStart).TotalMilliseconds;
        Assert.True(built.IsSuccess, string.Join(" | ", built.Diagnostics.Select(d => d.Message)));
        var report = Assert.IsType<FirmamentPerforationReport>(built.Value.Perforation);
        Assert.Equal(report.Rows * report.Columns, report.InstanceCount);
        Assert.Equal(133, report.InstanceCount);
        // 133 congruent openings are verified by one- and two-opening STEP round trips plus an exact census.
        Assert.Equal("congruent-specimens", report.VerificationBasis);
        Assert.Equal(report.InstanceCount * 3, built.Value.RuntimeCorrespondence!.Descendants.Count);
        var first = built.Value.RuntimeCorrespondence.Descendants.Where(d => d.SourceStableId == "perforation:Body.Vents.Row0.Col0").ToArray();
        Assert.Contains(first, d => d.Role == Aetheris.Kernel.Firmament.Materializer.SemanticTopologyRole.HoleWallFace && d.Face is not null);
        Assert.Contains(first, d => d.Role == Aetheris.Kernel.Firmament.Materializer.SemanticTopologyRole.HoleEntryLoop && d.Loop is not null);
        Assert.Contains(first, d => d.Role == Aetheris.Kernel.Firmament.Materializer.SemanticTopologyRole.HoleExitLoop && d.Loop is not null);
        Assert.Equal(report.InstanceCount + 5, report.Faces);
        Assert.True(report.Manifold && report.StepReimportedManifold);
        Assert.NotEmpty(built.Value.StepText);
        var output = Environment.GetEnvironmentVariable("AETHERIS_CYLINDRICAL_ORDNING_OBJ_OUTPUT");
        var displayOptions = string.IsNullOrWhiteSpace(output) ? DisplayTessellationOptions.Default
            : new DisplayTessellationOptions(System.Math.PI / 24, 0.01, 24, 1024);
        var displayStart = Stopwatch.GetTimestamp();
        var display = BrepDisplayTessellator.TessellateBounded(built.Value.RuntimeBody!, displayOptions,
            executionTimeout: TimeSpan.FromSeconds(string.IsNullOrWhiteSpace(output) ? 60 : 120));
        var displayMilliseconds = Stopwatch.GetElapsedTime(displayStart).TotalMilliseconds;
        Assert.True(display.IsSuccess, string.Join(" | ", display.Diagnostics.Select(d => d.Message)));
        Assert.Equal(report.Faces, display.Value.FacePatches.Count);
        var perfOutput = Environment.GetEnvironmentVariable("AETHERIS_CYLINDRICAL_PERF_REPORT_OUTPUT");
        if (!string.IsNullOrWhiteSpace(perfOutput))
            File.WriteAllText(perfOutput, JsonSerializer.Serialize(new
            {
                buildExportReimportMs = buildMilliseconds, displayTessellationMs = displayMilliseconds,
                displayOptions, stepBytes = System.Text.Encoding.UTF8.GetByteCount(built.Value.StepText),
                report.InstanceCount, report.Faces, report.Edges, report.Vertices,
                report.MaximumCurveBoundMm, report.MaximumPcurveBoundMm
            }, new JsonSerializerOptions { WriteIndented = true }));
        if (!string.IsNullOrWhiteSpace(output))
        {
            var lines = new List<string>(); var offset = 1;
            foreach (var patch in display.Value.FacePatches)
            {
                lines.Add($"g Face{patch.FaceId.Value}");
                lines.AddRange(patch.Positions.Select(p => FormattableString.Invariant($"v {p.X:R} {p.Y:R} {p.Z:R}")));
                for (var k = 0; k < patch.TriangleIndices.Count; k += 3)
                    lines.Add($"f {offset + patch.TriangleIndices[k]} {offset + patch.TriangleIndices[k + 1]} {offset + patch.TriangleIndices[k + 2]}");
                offset += patch.Positions.Count;
            }
            File.WriteAllLines(output, lines);
        }
    }

    [Fact]
    public void BlendedOrdningBlank_PreservesOneHundredThirtyThreeHoles()
    {
        var source = CylindricalSource.Replace("WallThickness: 0.8mm", "WallThickness: 0.8mm; BottomBlendRadius: 8mm", StringComparison.Ordinal);
        var built = FirmamentBuildAndExport.CompileSource(source);
        Assert.True(built.IsSuccess, string.Join(" | ", built.Diagnostics.Select(d => d.Message)));
        var report = Assert.IsType<FirmamentPerforationReport>(built.Value.Perforation);
        Assert.Equal(133, report.InstanceCount);
        Assert.Equal(140, report.Faces);
        Assert.True(report.Manifold && report.StepReimportedManifold);
        Assert.Equal(2, built.Value.RuntimeBody!.Geometry.Surfaces.Count(s => s.Value.Kind == Aetheris.Kernel.Core.Geometry.SurfaceGeometryKind.Torus));
        var output = Environment.GetEnvironmentVariable("AETHERIS_HOLLOW_BLEND_OBJ_OUTPUT");
        if (string.IsNullOrWhiteSpace(output)) return;
        var display = BrepDisplayTessellator.TessellateBounded(built.Value.RuntimeBody,
            new DisplayTessellationOptions(System.Math.PI / 24, 0.01, 24, 1024), executionTimeout: TimeSpan.FromSeconds(120));
        Assert.True(display.IsSuccess, string.Join(" | ", display.Diagnostics.Select(d => d.Message)));
        Assert.Equal(140, display.Value.FacePatches.Count);
        var lines = new List<string>(); var offset = 1;
        foreach (var patch in display.Value.FacePatches)
        {
            lines.Add($"g Face{patch.FaceId.Value}");
            lines.AddRange(patch.Positions.Select(p => FormattableString.Invariant($"v {p.X:R} {p.Y:R} {p.Z:R}")));
            for (var k = 0; k < patch.TriangleIndices.Count; k += 3)
                lines.Add($"f {offset + patch.TriangleIndices[k]} {offset + patch.TriangleIndices[k + 1]} {offset + patch.TriangleIndices[k + 2]}");
            offset += patch.Positions.Count;
        }
        File.WriteAllLines(output, lines);
    }

    [Fact]
    public void HollowBottomBlend_RejectsInvalidRadiusAndUnit()
    {
        var source = CylindricalSource.Replace("WallThickness: 0.8mm", "WallThickness: 0.8mm; BottomBlendRadius: 0.8mm", StringComparison.Ordinal);
        var radius = FirmamentV2Parser.Parse(source);
        Assert.False(radius.IsSuccess);
        Assert.Contains("firmament-v2-hollow-bottom-blend-invalid", radius.Diagnostics);
        var unit = FirmamentV2Parser.Parse(source.Replace("BottomBlendRadius: 0.8mm", "BottomBlendRadius: 8cm", StringComparison.Ordinal));
        Assert.False(unit.IsSuccess);
        Assert.Contains("firmament-v2-hollow-bottom-blend-invalid", unit.Diagnostics);
    }

    [Fact]
    public void InvalidPitchAndNoRoomFailWithSpecificDiagnostics()
    {
        var overlap = FirmamentBuildAndExport.CompileSource(GridSource.Replace("Pitch: 12mm", "Pitch: 6mm", StringComparison.Ordinal));
        Assert.False(overlap.IsSuccess);
        Assert.Contains(overlap.Diagnostics, d => d.Message.Contains("perforation-hole-overlap", StringComparison.Ordinal));
        var noRoom = FirmamentBuildAndExport.CompileSource(GridSource.Replace("Margin: 3mm", "Margin: 15mm", StringComparison.Ordinal));
        Assert.False(noRoom.IsSuccess);
        Assert.Contains(noRoom.Diagnostics, d => d.Message.Contains("perforation-support-too-small", StringComparison.Ordinal));
        var cylindricalFieldOnPanel = FirmamentBuildAndExport.CompileSource(GridSource.Replace("Margin: 3mm", "Margin: 3mm; CircumferentialPitch: 12mm", StringComparison.Ordinal));
        Assert.False(cylindricalFieldOnPanel.IsSuccess);
        Assert.Contains(cylindricalFieldOnPanel.Diagnostics, d => d.Message.Contains("perforation-planar-cylindrical-field-unsupported", StringComparison.Ordinal));
    }

    [Fact]
    public void CylinderSupport_ReportsExactTopologyBoundaryWithoutExportingUncutStock()
    {
        const string source = """
            Model Sleeve {
              Units: mm
              Cylinder Tube { Radius: 20mm; Height: 60mm }
              Modify Tube {
                Perforation Vents { On: Wall; Diameter: 6mm; Layout: Hex; Pitch: 9mm; Margin: 8mm }
              }
            }
            """;
        var built = FirmamentBuildAndExport.CompileSource(source);
        Assert.False(built.IsSuccess);
        Assert.Contains(built.Diagnostics, d => d.Message.Contains("perforation-cylindrical-topology-unavailable", StringComparison.Ordinal));
    }

    [Fact]
    public void SchemaAndLanguageService_ExposeCanonicalFields()
    {
        var schema = Assert.IsType<FirmamentConstructSchema>(FirmamentSemanticSchemas.Get("Perforation"));
        Assert.Contains(schema.Fields, field => field.Name == "Diameter" && field.Required);
        Assert.Contains(schema.Fields, field => field.Name == "Layout" && field.Choices.Contains("Hex"));
        Assert.Contains(schema.Fields, field => field.Name == "Layout" && field.Choices.Contains("CylindricalStaggered"));
        Assert.Contains(schema.Fields, field => field.Name == "CircumferentialPitch");
        const string source = "Model X { Units: mm Box Body { Size: [30mm,30mm,2mm] } Modify Body { Perforation Vent {\n Dia";
        var completion = FirmamentLanguageService.Complete(source, "x", "r1", source.Length);
        Assert.Equal("Perforation", completion.Context);
        Assert.Contains(completion.Fields, field => field.Name == "Diameter");
        const string cylindricalSource = "Struct X { Cylinder<Hollow> Body { Radius: 20mm Height: 60mm WallThickness: 0.8mm Openings: [Top] } Modify Body { Perforation Vent {\n Circ";
        var cylindricalCompletion = FirmamentLanguageService.Complete(cylindricalSource, "x", "r1", cylindricalSource.Length);
        Assert.Equal("Perforation", cylindricalCompletion.Context);
        Assert.Contains(cylindricalCompletion.Fields, field => field.Name == "CircumferentialPitch");
    }
}