Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

14.9 KB
Raw Blame
using System.Diagnostics;
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Brep.Tessellation;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Step242;
using Aetheris.Kernel.Core.Import;
using Aetheris.Kernel.Firmament.Assembly;
using Aetheris.Kernel.Firmament;
using Aetheris.Server.Contracts;

namespace Aetheris.Server.Api;

public static class AssemblyDisplayService
{
    internal static DisplayFaceSourceDto FaceSource(Aetheris.Kernel.Core.Brep.BrepBody body, Aetheris.Kernel.Core.Topology.FaceId faceId)
        => new(faceId.Value, body.Bindings.GetFaceBinding(faceId).SourceStepEntityId, body.GetFaceSurface(faceId).Kind.ToString(),
            body.GetLoopIds(faceId).SelectMany(body.GetCoedgeIds).Select(id => body.Topology.GetCoedge(id).EdgeId.Value).Distinct().ToArray());

    public static bool TryBuildStep(Step242ProductStructure structure, out AssemblyDisplayPacketDto? packet, out string error)
    {
        packet = null; error = string.Empty;
        var watch = Stopwatch.StartNew();
        var definitions = new List<AssemblyDisplayDefinitionDto>();
        var displayDiagnostics = new List<DisplayDiagnosticDto>();
        foreach (var definition in structure.Definitions.Where(item => item.Geometry is not null).OrderBy(item => item.StableId, StringComparer.Ordinal))
        {
            var mesh = BrepDisplayTessellator.TessellateBoundedPartial(definition.Geometry!, DisplayTessellationOptions.ForViewport(definition.Geometry!));
            var qualification = BrepImportQualification.WithDisplay(definition.Geometry!, mesh);
            displayDiagnostics.AddRange(qualification.Reasons.Concat(qualification.DisplayReasons).Select(reason => new DisplayDiagnosticDto(
                reason.Code, reason.Message, reason.FaceId, null, "step-import", "Inspect definition " + definition.StableId + ", STEP entity " + reason.StepEntityId)));
            var tessellation = ApiMappings.ToTessellationResponse(mesh);
            definitions.Add(new(definition.StableId, definition.Name, tessellation.FacePatches, qualification, tessellation.EdgePolylines,
                definition.Geometry!.Topology.Faces.Select(face => FaceSource(definition.Geometry!, face.Id)).ToArray()));
        }
        var byDefinition = structure.Definitions.ToDictionary(item => item.StableId, StringComparer.Ordinal);
        var byOccurrence = structure.Occurrences.ToDictionary(item => item.StableId, StringComparer.Ordinal);
        var rootId = "step-root:" + structure.RootDefinitionStableId;
        var world = new Dictionary<string, Transform3D>(StringComparer.Ordinal);
        Transform3D World(Step242ImportedProductOccurrence occurrence)
        {
            if (world.TryGetValue(occurrence.StableId, out var cached)) return cached;
            var local = Transform3D.FromRowMajor(occurrence.LocalTransform);
            return world[occurrence.StableId] = occurrence.ParentStableId is null ? local : local * World(byOccurrence[occurrence.ParentStableId]);
        }
        var occurrences = new List<AssemblyDisplayOccurrenceDto>
        {
            new(rootId, byDefinition.GetValueOrDefault(structure.RootDefinitionStableId)?.Name ?? "ImportedAssembly", rootId,
                null, null, "Assembly", Transform3D.Identity.ToRowMajor(), "ImportedOccurrence")
        };
        var points = new List<Point3D>();
        foreach (var occurrence in structure.Occurrences)
        {
            if (!byDefinition.TryGetValue(occurrence.DefinitionStableId, out var definition))
            {
                error = $"STEP occurrence '{occurrence.Name}' refers to missing definition '{occurrence.DefinitionStableId}'.";
                return false;
            }
            var transform = World(occurrence);
            occurrences.Add(new(occurrence.StableId, occurrence.Name, occurrence.StableId,
                occurrence.ParentStableId ?? rootId, occurrence.DefinitionStableId,
                definition.Geometry is null ? "Assembly" : "Part", transform.ToRowMajor(), "ImportedOccurrence"));
            if (definition.Geometry is null) continue;
            foreach (var vertex in definition.Geometry.Topology.Vertices)
                if (definition.Geometry.TryGetVertexPoint(vertex.Id, out var point)) points.Add(transform.Apply(point));
        }
        var minimum = points.Count == 0 ? new[] { 0d, 0d, 0d } : new[] { points.Min(p => p.X), points.Min(p => p.Y), points.Min(p => p.Z) };
        var maximum = points.Count == 0 ? new[] { 0d, 0d, 0d } : new[] { points.Max(p => p.X), points.Max(p => p.Y), points.Max(p => p.Z) };
        watch.Stop();
        var performance = new Dictionary<string, double>(structure.Performance ?? new Dictionary<string, double>(), StringComparer.Ordinal)
        {
            ["displayPreparationMilliseconds"] = watch.Elapsed.TotalMilliseconds,
            ["definitionCount"] = definitions.Count,
            ["occurrenceCount"] = occurrences.Count - 1
        };
        packet = new("aetheris/cadmata-assembly-display/m3", occurrences[0].Name, rootId, definitions, occurrences,
            [], [], new(minimum, maximum), displayDiagnostics, performance);
        return true;
    }

    public static bool TryBuild(string path, out AssemblyDisplayPacketDto? packet, out string error)
    {
        packet = null; error = string.Empty;
        if (string.IsNullOrWhiteSpace(path) || !File.Exists(path)) { error = $"Assembly source '{path}' was not found."; return false; }
        var source = File.ReadAllText(path);
        if (Aetheris.Kernel.Firmament.Scene.SceneAuthoring.HasRoot(source))
        {
            using var session = new Aetheris.Kernel.Firmament.Scene.FirmamentSceneSession();
            var scene = session.CompileFile(path);
            if (!scene.IsSuccess || scene.Scene is null) { error = string.Join(Environment.NewLine, scene.Diagnostics.Select(d => d.Code+": "+d.Message)); return false; }
            packet = FromDisplay(DisplayProjection.Project(scene.Scene));
            return true;
        }
        if (!path.EndsWith(".firmasm", StringComparison.OrdinalIgnoreCase) &&
            !System.Text.RegularExpressions.Regex.IsMatch(source, @"(?m)^\s*Assembly\s+"))
        {
            var part = FirmamentBuildAndExport.CompileSource(source, Path.GetDirectoryName(Path.GetFullPath(path)));
            if (!part.IsSuccess) { error = string.Join(Environment.NewLine, part.Diagnostics.Select(d => d.Message)); return false; }
            var body = part.Value.RuntimeBody;
            if (body is null)
            {
                var imported = Step242Importer.ImportBody(part.Value.StepText);
                body = imported.IsSuccess ? imported.Value : null;
            }
            if (body is null) { error = "display-part-brep-unavailable"; return false; }
            var id = part.Value.Cir?.DefinitionId ?? "part-definition:"+part.Value.ExportedFeatureId;
            var definition = AssemblyDisplayMeshExporter.PrepareDefinition(id, part.Value.ExportedFeatureId, body) with { Cir = part.Value.Cir, Shader = CirShaderArtifactProvider.Resolve(part.Value.Cir), GeometryRevision = part.Value.Cir?.DefinitionId,
                Concepts = Aetheris.Kernel.Firmament.Visualization.ConceptDisplayProjection.Project(part.Value) };
            packet = FromDisplay(new("aetheris/display-mesh/1", Path.GetFileNameWithoutExtension(path), "mm", [definition],
                [new("part", Path.GetFileNameWithoutExtension(path), null, id, Transform3D.Identity.ToRowMajor(), part.Value.ExportedFeatureId)]));
            return true;
        }
        var watch = Stopwatch.StartNew();
        var compilation = string.Equals(Path.GetExtension(path), ".firmasm", StringComparison.OrdinalIgnoreCase)
            ? new FirmamentAssemblyDocumentCompiler().CompileFile(path).Compilation
            : new AssemblyM1Pipeline().CompileFile(path);
        if (!compilation.IsSuccess || compilation.Ir is null || compilation.Geometry is null)
        {
            error = string.Join(Environment.NewLine, compilation.Diagnostics.Select(diagnostic => $"{diagnostic.Code}: {diagnostic.Message}"));
            return false;
        }
        var display = AssemblyDisplayMeshExporter.Export(compilation);
        var definitions = display.Definitions.Select(LegacyDefinition).ToList();
        var diagnostics = display.Definitions.SelectMany(d => d.Diagnostics.Select(w =>
            new DisplayDiagnosticDto(w.Code, w.Message, null, null, "definition-tessellation", d.Id + ":" + w.FaceId))).ToList();
        var artifactByIdentity = compilation.Geometry.Artifact.Definitions.ToDictionary(item => item.DefinitionIdentity, item => item.StableId, StringComparer.Ordinal);
        var occurrences = compilation.Ir.Instances.OrderBy(item => item.Path.Segments.Count).ThenBy(item => item.Path.ToString(), StringComparer.Ordinal).Select(instance => new AssemblyDisplayOccurrenceDto(
            instance.StableId, instance.Path.Segments[^1], instance.Path.ToString(), instance.ParentStableId,
            instance.Kind == AssemblyInstanceKind.Part ? artifactByIdentity.GetValueOrDefault(instance.DefinitionIdentity)
                : (compilation.Ir.AssemblyDefinitions ?? []).SingleOrDefault(item => item.DefinitionIdentity == instance.DefinitionIdentity)?.StableId,
            instance.Kind.ToString(), (instance.ResolvedTransform ?? AssemblyTransform.Identity).Matrix, instance.PlacementAuthority.ToString(),
            compilation.Ir.Instances.Where(candidate => candidate.Path.Segments.Count >= instance.Path.Segments.Count
                && candidate.Path.Segments.Take(instance.Path.Segments.Count).SequenceEqual(instance.Path.Segments)).Select(candidate => candidate.StableId).ToArray())).ToArray();
        var mates = compilation.Ir.Mates.Select(mate => new AssemblyDisplayMateDto(mate.StableId, mate.Name, mate.InterfaceStableId,
            mate.Roles.Select(role => $"{role.Role}: {role.ParticipantPath}").ToArray(), mate.ConstraintIds, mate.ValidationStatus)).ToArray();
        var tolerances = compilation.Ir.ToleranceStackups.Select(stack => new AssemblyDisplayToleranceDto(stack.Name, stack.Passed, stack.Nominal, stack.WorstCaseMinimum, stack.WorstCaseMaximum, stack.Unit,
            stack.Contributions.Select(contribution => $"{contribution.OriginInstancePath}: {contribution.RelationStableId}").ToArray(),
            stack.Contributions.SelectMany(contribution => contribution.ExpandedContributors ?? []).Select(item => $"{item.Provenance}: {item.Nominal:G6} {item.Unit} [{item.Nominal + item.LowerTolerance:G6}, {item.Nominal + item.UpperTolerance:G6}]").ToArray())).ToArray();
        var modules = (compilation.Ir.AssemblyDefinitions ?? []).Select(definition => new AssemblyDisplayModuleDefinitionDto(
            definition.StableId, definition.DefinitionIdentity, definition.TemplateName, definition.SpecializationIdentity,
            definition.Provenance.Select(item => $"{item.Stage}:{item.Identity}:{item.Evidence}").ToArray(),
            definition.PublicSemantics.Select(semantic => new AssemblyDisplayPublicSemanticDto(semantic.ExposedName ?? semantic.StableIdentity, semantic.Type.Name,
                semantic.Capabilities.Values.Select(item => item.Name).Order(StringComparer.Ordinal).ToArray(), semantic.Bindings.Select(item => item.Kind).Order(StringComparer.Ordinal).ToArray(),
                semantic.Provenance.LastOrDefault(item => item.Stage == "assembly-expose")?.Evidence)).ToArray(), definition.SolveMilliseconds)).ToArray();
        var metrics = compilation.Geometry.Artifact.Instances.Select(item => item.Metrics).ToArray();
        var minimum = metrics.Length == 0 ? new[] { 0d,0d,0d } : new[] { metrics.Min(item => item.Minimum[0]), metrics.Min(item => item.Minimum[1]), metrics.Min(item => item.Minimum[2]) };
        var maximum = metrics.Length == 0 ? new[] { 0d,0d,0d } : new[] { metrics.Max(item => item.Maximum[0]), metrics.Max(item => item.Maximum[1]), metrics.Max(item => item.Maximum[2]) };
        watch.Stop();
        packet = new("aetheris/cadmata-assembly-display/m3", compilation.Ir.Name, compilation.Ir.RootInstanceStableId, definitions, occurrences, mates, tolerances,
            new(minimum, maximum), diagnostics, new Dictionary<string, double> { ["packetMilliseconds"] = watch.Elapsed.TotalMilliseconds, ["definitionCount"] = definitions.Count, ["moduleDefinitionCount"] = modules.Length, ["occurrenceCount"] = occurrences.Length }, modules,
            display);
        return true;
    }

    private static AssemblyDisplayPacketDto FromDisplay(AssemblyDisplayMeshDocument display)
    {
        var vertices = display.Definitions.ToDictionary(d => d.Id, d => d.Positions, StringComparer.Ordinal);
        var points = display.Occurrences.Where(o => o.DefinitionId is not null).SelectMany(o =>
        {
            var p = vertices[o.DefinitionId!]; var t = Transform3D.FromRowMajor(o.Transform);
            return Enumerable.Range(0, p.Length/3).Select(i => t.Apply(new Point3D(p[i*3], p[i*3+1], p[i*3+2])));
        });
        var boundsPoints = display.MinimumMm is null || display.MaximumMm is null ? points.ToArray() : [];
        var minimum = display.MinimumMm ?? (boundsPoints.Length == 0 ? [0d,0d,0d] : new[] { boundsPoints.Min(p=>p.X), boundsPoints.Min(p=>p.Y), boundsPoints.Min(p=>p.Z) });
        var maximum = display.MaximumMm ?? (boundsPoints.Length == 0 ? [0d,0d,0d] : new[] { boundsPoints.Max(p=>p.X), boundsPoints.Max(p=>p.Y), boundsPoints.Max(p=>p.Z) });
        var occurrences = display.Occurrences.Select(o => new AssemblyDisplayOccurrenceDto(o.Id, o.Path.Split('.').Last(), o.Path, o.ParentId,
            o.DefinitionId, o.Kind ?? "Part", o.Transform, "CompiledDisplay")).ToArray();
        return new("aetheris/cadmata-assembly-display/m3", display.Name, occurrences.Single(o=>o.ParentStableId is null).StableId,
            display.Definitions.Select(LegacyDefinition).ToArray(), occurrences, [], [], new(minimum,maximum), [], new Dictionary<string,double>(), Display: display);
    }

    // Compatibility transport only: geometry and face ranges come from the shared projector.
    private static AssemblyDisplayDefinitionDto LegacyDefinition(AssemblyDisplayMeshDefinition definition)
    {
        var ranges = definition.Ranges ?? [new(0, definition.Indices.Length/3, "face:0", definition.Id)];
        var faces = ranges.Select(range =>
        {
            var indices = definition.Indices.Skip(range.StartTriangle*3).Take(range.TriangleCount*3).ToArray();
            var vertices = indices.Distinct().Order().ToArray();
            var local = vertices.Select((id,index)=>(id,index)).ToDictionary(v=>v.id,v=>v.index);
            var positions = vertices.Select(i=>new Point3Dto(definition.Positions[i*3],definition.Positions[i*3+1],definition.Positions[i*3+2])).ToArray();
            var normals = vertices.Select(i=>new Vector3Dto(definition.Normals[i*3],definition.Normals[i*3+1],definition.Normals[i*3+2])).ToArray();
            return new FacePatchDto(int.Parse(range.FaceId.AsSpan("face:".Length), System.Globalization.CultureInfo.InvariantCulture),
                positions,normals,indices.Select(i=>local[i]).ToArray(),definition.MeshPipeline,null);
        }).ToArray();
        return new(definition.Id,definition.Identity,faces);
    }
}