Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

17.9 KB
Raw Blame
using Aetheris.Kernel.Firmament.FirmamentV2.Syntax;
using System.Globalization;
using System.Text.RegularExpressions;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Firmament.FirmamentV2;
using Aetheris.Semantics;

namespace Aetheris.Kernel.Firmament.Assembly;

/// <summary>Bounded frame authoring; lowers layout to the existing frame constraint solver.</summary>
internal static class AssemblyFrameAuthoring
{
    internal static AssemblyFrameTransformSource? Parse(DeclarationSyntax declaration, string sourceIdentity,
        List<AssemblyDiagnostic> diagnostics, int sourceOffset = 0)
    {
        var errors = new List<string>();
        var fields = new FirmamentSyntaxFields(declaration, errors);
        var from = fields.Reference("From");
        if (from is null) fields.Invalid("From");
        var translation = Vector("TranslateLocal", "mm", [0, 0, 0]);
        var normal = Vector("Normal", "", null);
        var up = Vector("Up", "", null);
        var axis = "Z";
        var angle = 0d;
        if (fields.Take("RotateLocal") is { } rotation)
        {
            if (rotation is ObjectSyntax obj)
            {
                // The anonymous rotation object has the same fields as ordinary
                // Placement/FrameTransform rotation, with no source rewriting.
                var type = new IdentifierSyntax("RotateLocal", obj.Span);
                var rotate = new FirmamentSyntaxFields(new(new(type, [], obj.Span), null, [], [], null, null, [], null, obj.Body, false, obj.Span), errors);
                axis = rotate.Reference("Axis") ?? "";
                angle = rotate.Number("Angle", "deg");
                if (axis is not ("X" or "Y" or "Z") || !double.IsFinite(angle)) rotate.Invalid("Angle");
                rotate.Complete();
            }
            else fields.Invalid("RotateLocal");
        }
        if ((normal is null) != (up is null)) fields.Invalid("Normal/Up");
        fields.Complete();
        foreach (var error in errors)
            diagnostics.Add(new(error.Split(':')[0], $"Frame '{declaration.Name?.Text}': {Aetheris.Kernel.Firmament.FirmamentV2.FirmamentInterop.FirmamentV2DiagnosticAdapter.MessageFor(error)}")
                { SourceSpan = new(sourceIdentity, sourceOffset + declaration.Span.Start, declaration.Span.Length) });
        return errors.Count == 0 ? new(declaration.Name!.Text, from!, translation!, axis, angle, normal, up,
            new(sourceIdentity, sourceOffset + declaration.Span.Start, declaration.Span.Length)) : null;

        double[]? Vector(string name, string unit, double[]? fallback)
        {
            var expression = fields.Take(name);
            if (expression is null) return fallback;
            if (FirmamentSyntaxValues.Vector(expression, unit, out var values) && values.Length == 3) return values;
            fields.Invalid(name); return fallback;
        }
    }

    internal static AssemblyFrameTransformSource? Parse(string name, string body, string targetField,
        string sourceIdentity, List<AssemblyDiagnostic> diagnostics)
    {
        var remaining = body;
        string? Field(string pattern, string group = "value")
        {
            var matches = Regex.Matches(remaining, pattern, RegexOptions.CultureInvariant);
            if (matches.Count > 1) diagnostics.Add(new("assembly-frame-duplicate-field", $"Frame '{name}' repeats a field."));
            if (matches.Count == 0) return null;
            remaining = Regex.Replace(remaining, pattern, "", RegexOptions.CultureInvariant);
            return matches[0].Groups[group].Value;
        }
        var from = Field($@"\b{targetField}\s*:\s*(?<value>[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\s*;?");
        var translate = Field(@"\bTranslateLocal\s*:\s*\[(?<value>[^]]+)\]\s*;?");
        var normal = Field(@"\bNormal\s*:\s*\[(?<value>[^]]+)\]\s*;?");
        var up = Field(@"\bUp\s*:\s*\[(?<value>[^]]+)\]\s*;?");
        var rotate = Field(@"\bRotateLocal\s*:\s*\{(?<value>[^{}]*)\}\s*;?");
        var axis = "Z"; double angle = 0;
        if (rotate is not null)
        {
            var m = Regex.Match(rotate, @"^\s*Axis\s*:\s*(?<axis>X|Y|Z)\s*;\s*Angle\s*:\s*(?<angle>[-+0-9.eE]+)deg\s*;?\s*$");
            if (!m.Success || !double.TryParse(m.Groups["angle"].Value, NumberStyles.Float, CultureInfo.InvariantCulture, out angle) || !double.IsFinite(angle))
                diagnostics.Add(new("assembly-frame-invalid-rotation", $"Frame '{name}' requires Axis X/Y/Z and a finite Angle in deg."));
            axis = m.Success ? m.Groups["axis"].Value : "Z";
        }
        if (from is null || !string.IsNullOrWhiteSpace(remaining.Replace(";", "")))
            diagnostics.Add(new("assembly-frame-invalid-fields", $"Frame '{name}' requires {targetField}; unknown or malformed fields: {remaining.Trim()}."));
        if ((normal is null) != (up is null)) diagnostics.Add(new("assembly-frame-invalid-basis", $"Frame '{name}' requires both Normal and Up."));
        double[]? Vector(string? value, bool lengths)
        {
            if (value is null) return null;
            var values = value.Split(',', StringSplitOptions.TrimEntries);
            var result = new double[3];
            if (values.Length != 3) { diagnostics.Add(new("assembly-frame-invalid-vector", $"Frame '{name}' requires three components.")); return null; }
            for (var i = 0; i < 3; i++)
            {
                var text = values[i];
                if (lengths)
                {
                    if (!FirmamentNumericEvaluation.TryEvaluateScalar(text,out result[i],out var unit) || unit != "mm" || !double.IsFinite(result[i]))
                        diagnostics.Add(new("assembly-frame-invalid-unit", $"Frame '{name}' translation components require finite mm length expressions."));
                    continue;
                }
                if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out result[i]) || !double.IsFinite(result[i]))
                    diagnostics.Add(new("assembly-frame-invalid-vector", $"Frame '{name}' requires finite numeric components."));
            }
            return result;
        }
        return from is null ? null : new(name, from, Vector(translate, true) ?? [0,0,0], axis, angle,
            Vector(normal, false), Vector(up, false), SemanticSourceSpan.Generated(sourceIdentity));
    }

    internal static (AssemblySource Source, IReadOnlyList<AssemblyInstanceIr> Instances) Lower(
        AssemblySource source, IReadOnlyList<AssemblyInstanceIr> original, List<AssemblyDiagnostic> diagnostics,
        IReadOnlyList<AssemblyJointIr> retainedJoints)
    {
        var instances = original.ToDictionary(i => i.Path.ToString(), StringComparer.Ordinal);
        var named = (source.FrameTransforms ?? []).GroupBy(f => f.Name).ToDictionary(g => g.Key, g => g.First(), StringComparer.Ordinal);
        foreach (var group in (source.FrameTransforms ?? []).GroupBy(f => f.Name).Where(g => g.Count() > 1))
            diagnostics.Add(new("assembly-frame-duplicate-name", $"FrameTransform '{group.Key}' is duplicated."));
        foreach (var name in named.Keys.Where(n => n is "World" or "Origin" or "Parent" || n.StartsWith("__Layout", StringComparison.Ordinal)))
            diagnostics.Add(new("assembly-frame-reserved-name", $"FrameTransform '{name}' uses a reserved name."));
        var interfaces = source.Interfaces.ToList(); var mates = source.Mates.ToList();
        var root = original.Single(i => i.ParentStableId is null);
        (AssemblyInstanceIr Owner, Transform3D Frame)? Resolve(string path, string context, HashSet<string> visiting, bool followExposed = false)
        {
            var key = path.EndsWith(".Frame", StringComparison.Ordinal) ? path[..^6] : path;
            if (named.TryGetValue(key, out var transform))
            {
                if (!visiting.Add(key)) { diagnostics.Add(new("assembly-frame-cycle", $"FrameTransform cycle at '{key}'.")); return null; }
                var resolved = Resolve(transform.From, root.Path.ToString(), visiting, followExposed);
                visiting.Remove(key);
                return resolved is { } value ? (value.Owner, Compose(value.Frame, transform, diagnostics)) : null;
            }
            if (path == "World") return (instances[root.Path.ToString()], Transform3D.Identity);
            if (path == "Origin") return (instances[context], Transform3D.Identity);
            if (path == "Parent")
            {
                var parent=instances[context].ParentStableId;
                if (parent is not null) return (instances.Values.Single(i=>i.StableId==parent),Transform3D.Identity);
                diagnostics.Add(new("assembly-frame-unresolved",$"'{context}' has no parent frame.")); return null;
            }
            if (!path.StartsWith(root.Path + ".", StringComparison.Ordinal) && path != root.Path.ToString())
            {
                var self = instances[context];
                var candidate = context + "." + path;
                if (!AssemblyM0Compiler.TryResolve(AssemblyPath.Parse(candidate), instances.Values, out _))
                    candidate = self.ParentStableId is null ? root.Path + "." + path
                        : instances.Values.Single(i => i.StableId == self.ParentStableId).Path + "." + path;
                path = candidate;
            }
            if (!AssemblyM0Compiler.TryResolve(AssemblyPath.Parse(path), instances.Values, out var reference)
                || !reference!.Value.TryBinding<ExactDatumFrameBinding>(out var frame))
            { diagnostics.Add(new("assembly-frame-unresolved", $"'{context}' cannot resolve exact published DatumFrame '{path}'.")); return null; }
            var owner = instances.Values.Where(i => path == i.Path.ToString() || path.StartsWith(i.Path + ".", StringComparison.Ordinal))
                .OrderByDescending(i => i.Path.Segments.Count).First();
            var semantic = reference.Value;
            if (!followExposed && !AssemblyKinematics.IsRigidPort(owner, semantic, original, retainedJoints))
            {
                diagnostics.Add(new("assembly-kinematic-moving-mount-unsupported", $"Placement '{context}' requires a rigid source mount; '{path}' moves internally."));
                return null;
            }
            var aliases = new HashSet<string>(StringComparer.Ordinal);
            while (followExposed && semantic.TryBinding<AssemblyExposedSemanticBinding>(out var alias) && aliases.Add(semantic.StableIdentity))
            {
                var target = AssemblyWorldQuery.ExposedTarget(instances.Values.ToArray(), owner, alias);
                owner = target.Owner; semantic = target.Value;
                if (semantic.TryBinding<ExactDatumFrameBinding>(out var exact)) frame = exact;
            }
            return (owner, Matrix(frame));
        }
        AssemblyPath Publish(AssemblyInstanceIr owner, string name, Transform3D frame, string origin)
        {
            owner = instances[owner.Path.ToString()];
            var m = frame.ToRowMajor(); var id = owner.SemanticRoot.StableIdentity + ":" + name;
            var value = new SemanticValue(id, new("AssemblyDatumFrame"), [new DatumFrameCapability()],
                [new ExactDatumFrameBinding(m[12],m[13],m[14],m[0],m[1],m[2],m[4],m[5],m[6],m[8],m[9],m[10],id)],
                provenance: [new("frame-layout", origin, name, SemanticSourceSpan.Generated(source.SourceIdentity))], exposedName: name);
            var semantic = owner.SemanticRoot;
            var updated = new SemanticValue(semantic.StableIdentity, semantic.Type, semantic.Capabilities.Values, semantic.Bindings,
                semantic.ExposedMembers.Values.Append(value), semantic.Provenance, semantic.AuthoredSourceSpan, semantic.GeneratedSourceSpan, semantic.ExposedName);
            instances[owner.Path.ToString()] = owner with { SemanticRoot = updated };
            return owner.Path.Append(name);
        }
        foreach (var (member, path) in Walk(source.Root, source.Root.Name))
        {
            if (member.FramePlacement is not { } layout) continue;
            var owner = instances[path];
            if (owner.ParentStableId is null || source.Anchor.ToString() == path || source.Anchor.ToString().StartsWith(path + ".", StringComparison.Ordinal))
                diagnostics.Add(new("assembly-placement-authority-conflict", $"Anchored occurrence '{path}' cannot also have authored placement."));
            bool DrivesOccurrence(MateSource mate)
            {
                bool Inside(MateRoleAssignment role) => role.Participant.ToString() == path
                    || role.Participant.ToString().StartsWith(path + ".", StringComparison.Ordinal);
                // A child's mate does not drive placement of its container.
                // Only endpoints owned by this occurrence can compete with it.
                if (mate.Roles.All(Inside)) return false;
                var definition = source.Interfaces.FirstOrDefault(d => d.Name == mate.InterfaceName);
                var movingRole = "B";
                if (definition?.Family == MechanicalInterfaceFamily.Fixed)
                {
                    var b = mate.Roles.FirstOrDefault(r => r.Role == "B");
                    var bOwner = b is null ? null : original.Where(i => b.Participant.ToString() == i.Path.ToString()
                        || b.Participant.ToString().StartsWith(i.Path + ".", StringComparison.Ordinal))
                        .OrderByDescending(i => i.Path.Segments.Count).FirstOrDefault();
                    if (bOwner is not null && (source.Anchor.ToString() == bOwner.Path.ToString()
                        || source.Anchor.ToString().StartsWith(bOwner.Path + ".", StringComparison.Ordinal))) movingRole = "A";
                }
                return mate.Roles.Any(r => (r.Role == movingRole || r.Role == "Moving")
                    && original.Where(i => r.Participant.ToString() == i.Path.ToString()
                        || r.Participant.ToString().StartsWith(i.Path + ".", StringComparison.Ordinal))
                        .OrderByDescending(i => i.Path.Segments.Count).FirstOrDefault()?.StableId == owner.StableId);
            }
            if (member.ExplicitTransform is not null || source.Mates.Any(DrivesOccurrence))
                diagnostics.Add(new("assembly-placement-authority-conflict", $"Occurrence '{path}' has both authored placement and another placement driver."));
            var from = Resolve(layout.From, path, []); var to = Resolve(layout.Target.From, path, [], followExposed: true);
            if (from is null || to is null) continue;
            if (from.Value.Owner.StableId != owner.StableId || to.Value.Owner.StableId == owner.StableId)
            { diagnostics.Add(new("assembly-placement-invalid-owner", $"Placement '{path}' requires a source frame on itself and a target on another occurrence.")); continue; }
            var suffix = Convert.ToHexString(System.Security.Cryptography.SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(path)))[..16];
            var a = Publish(owner, "__LayoutSource" + suffix, from.Value.Frame, layout.From);
            var b = Publish(to.Value.Owner, "__LayoutTarget" + suffix, Compose(to.Value.Frame, layout.Target, diagnostics), layout.Target.From);
            var name = "__Layout" + suffix;
            if (layout.JointFamily is { } family)
            {
                interfaces.Add(new("interface:" + name, name, [new("A", ["DatumFrameCapable"]),new("B", ["DatumFrameCapable"])],
                    [new(PlacementConstraintKind.FrameCoincident,"A",".","B",".")],
                    AdmittedFreeMotions: family == MechanicalInterfaceFamily.Revolute ? ["rotation:about-axis"] : [],
                    Family: family, SourceSpan: layout.Target.SourceSpan));
                mates.Add(new(layout.MateName!,name,[new("A",b),new("B",a)],layout.Target.SourceSpan));
            }
            else
            {
                interfaces.Add(new("interface:" + name, name, [new("Moving", ["DatumFrameCapable"]),new("Target", ["DatumFrameCapable"])],
                    [new(PlacementConstraintKind.FrameCoincident,"Moving",".","Target",".")], SourceSpan: layout.Target.SourceSpan, CompilerOwnedExpansion: true) { IsFramePlacement = true });
                mates.Add(new(name,name,[new("Moving",a),new("Target",b)],layout.Target.SourceSpan));
            }
        }
        // Validate unused named transforms too: a malformed/cyclic declaration must not disappear.
        foreach (var name in named.Keys) Resolve(name + ".Frame", root.Path.ToString(), []);
        return (source with { Interfaces = interfaces, Mates = mates }, original.Select(i => instances[i.Path.ToString()]).ToArray());
    }

    private static IEnumerable<(AssemblyMemberSource Member, string Path)> Walk(AssemblyMemberSource member, string path)
    {
        yield return (member,path);
        foreach (var child in member.Children) foreach (var item in Walk(child,path + "." + child.Name)) yield return item;
    }
    internal static Transform3D Matrix(ExactDatumFrameBinding f) => Transform3D.FromRowMajor(
        [f.XAxisX,f.XAxisY,f.XAxisZ,0,f.YAxisX,f.YAxisY,f.YAxisZ,0,f.ZAxisX,f.ZAxisY,f.ZAxisZ,0,f.OriginX,f.OriginY,f.OriginZ,1]);
    internal static Transform3D Compose(Transform3D frame, AssemblyFrameTransformSource spec, List<AssemblyDiagnostic> diagnostics)
    {
        var basis = Transform3D.Identity;
        if (spec.Normal is { } n && spec.Up is { } u)
        {
            var z = new Vector3D(n[0],n[1],n[2]); var up = new Vector3D(u[0],u[1],u[2]);
            if (!z.TryNormalize(out z) || !(up - z * up.Dot(z)).TryNormalize(out var y))
            { diagnostics.Add(new("assembly-frame-invalid-basis", $"Frame '{spec.Name}' has zero Normal or parallel Up.")); return frame; }
            var x = y.Cross(z);
            basis = Transform3D.FromRowMajor([x.X,x.Y,x.Z,0,y.X,y.Y,y.Z,0,z.X,z.Y,z.Z,0,0,0,0,1]);
        }
        var radians = spec.RotationDegrees * Math.PI / 180;
        var rotation = spec.RotationAxis switch { "X" => Transform3D.CreateRotationX(radians), "Y" => Transform3D.CreateRotationY(radians), _ => Transform3D.CreateRotationZ(radians) };
        return rotation * basis * Transform3D.CreateTranslation(new(spec.Translation[0],spec.Translation[1],spec.Translation[2])) * frame;
    }
}