Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

14.7 KB
Raw Blame
using Aetheris.Kernel.Firmament.FirmamentV2;
using Aetheris.Kernel.Firmament.FirmamentV2.Syntax;

namespace Aetheris.Kernel.Firmament.Materializer;

/// <summary>Exact full-length finish of one polygon corner in an extruded profile.</summary>
public static class ProfileLongitudinalEdgeFinish
{
    public const double Clearance = .01;
    public static bool IsLongitudinal(DeclarationSyntax declaration) => declaration.Type.Name.Text == "EdgeFinish"
        && declaration.Body?.Statements.OfType<FieldSyntax>().Any(f => (FirmamentSyntaxFields.SameField(f.Name.Text,"Face") || FirmamentSyntaxFields.SameField(f.Name.Text,"On"))
            && FirmamentSyntaxValues.Reference(f.Value) == "Longitudinal") == true;
    public static bool Requested(string source) => ProfileBoundaryChamferSourceBinder.FinishDeclarations(source).Any(IsLongitudinal);

    public sealed record Result(ResolvedProfile2D? Profile, string? Name, string? Kind, string? Diagnostic, double Size = 0, string? Target = null, bool AddsMaterial = false);
    public sealed record Batch(ResolvedProfile2D? Profile, IReadOnlyList<Result> Finishes, string? Diagnostic);
    public static Batch ApplyAll(string source, ResolvedProfile2D profile, string body)
    {
        var declarations = ProfileBoundaryChamferSourceBinder.FinishDeclarations(source).ToArray();
        if (declarations.Length > 0 && (profile.Loops.Count != 1 || !profile.Loops[0].IsOuter
            || profile.Loops[0].Segments.Any(s => s.Geometry is not LineArcLineSegment2D)))
            return new(null, [], "longitudinal-edge-finish: Start with a polygonal outer profile without inner loops.");
        var results = new List<Result>();
        var names = new HashSet<string>(StringComparer.Ordinal);
        var targets = new HashSet<string>(StringComparer.Ordinal);
        foreach (var declaration in declarations)
        {
            var finish = ApplyOne(source, declaration, profile, body);
            if (finish.Profile is null) return new(null, results, finish.Diagnostic);
            if (!names.Add(finish.Name!) || !targets.Add(finish.Target!))
                return new(null, results, "longitudinal-edge-finish: Each finish needs a unique name and a different original corner.");
            results.Add(finish);
            profile = finish.Profile;
        }
        return new(profile, results, null);
    }
    public static Result Apply(string source, ResolvedProfile2D profile, string body)
    {
        var declarations = ProfileBoundaryChamferSourceBinder.FinishDeclarations(source).ToArray();
        return declarations.Length == 1 ? ApplyOne(source, declarations[0], profile, body)
            : new(null, null, null, "longitudinal-edge-finish: Expected one finish.");
    }
    private static Result ApplyOne(string source, DeclarationSyntax declaration, ResolvedProfile2D profile, string body)
    {
        Result Fail(string reason) => new(null, declaration.Name?.Text, null, "longitudinal-edge-finish:" + declaration.Name?.Text + ": " + reason);
        var errors = new List<string>(); var fields = new FirmamentSyntaxFields(declaration, errors);
        if (declaration.Name is null) return Fail("Give the edge finish a name.");
        var receiver = FirmamentV2Parser.MechanicalDeclarations(FirmamentSyntaxParser.Parse(source).Document.Statements)
            .SingleOrDefault(d => d.Type.Name.Text == "Modify" && d.Body?.Statements.OfType<DeclarationSyntax>().Any(f => f.Span == declaration.Span) == true);
        if (receiver?.Name?.Text != body) return Fail("The selected edge must belong to the modified extrusion.");
        var face = FirmamentSyntaxValues.Reference(fields.Take("Face") ?? fields.Take("On"));
        var target = FirmamentSyntaxValues.Reference(fields.Take("Target"));
        var kind = FirmamentSyntaxValues.Reference(fields.Take("Kind"));
        var variant = declaration.Type.Arguments.Count == 1 ? FirmamentSyntaxValues.Reference(declaration.Type.Arguments[0].Value) : null;
        if (declaration.Type.Arguments.Count > 1 || declaration.Type.Arguments.Count == 1 && variant is not ("Fillet" or "Chamfer")) return Fail("Use EdgeFinish<Fillet> or EdgeFinish<Chamfer>.");
        if (kind is not null && variant is not null && kind != variant) return Fail("Kind must agree with the EdgeFinish variant.");
        kind ??= variant;
        var radius = fields.Take("Radius"); var distance = fields.Take("Distance");
        if (radius is not null && distance is not null || kind is not ("Fillet" or "Chamfer") || face != "Longitudinal"
            || kind == "Fillet" && radius is null || kind == "Chamfer" && distance is null
            || !FirmamentSyntaxValues.TryMeasure(radius ?? distance, "mm", out var amount) || !double.IsFinite(amount) || amount < Clearance)
            return Fail("Use a fillet Radius or chamfer Distance of at least 0.01 mm, and Face: Longitudinal.");
        fields.Complete(); if (errors.Count != 0) return Fail(string.Join("; ", errors));
        var parts = target?.Split('.') ?? [];
        if (parts.Length != 4 || parts[0] != profile.Name || parts[1] != "Outer" || parts[3] != "Start") return Fail("Select one source-owned longitudinal corner edge.");
        if (profile.Loops.Count != 1 || !profile.Loops[0].IsOuter || profile.Loops[0].Segments.Any(s => s.Geometry is not (LineArcLineSegment2D or LineArcCircularArc2D)))
            return Fail("Full-length corner finishes currently require a single polygonal outer profile without inner loops.");
        var loop = profile.Loops[0]; var segments = loop.Segments.ToArray();
        if (segments.Count(s => s.Name == parts[2]) != 1) return Fail("The selected corner is missing or ambiguous in this profile.");
        var index = Array.FindIndex(segments, s => s.Name == parts[2]);
        if (index < 0) return Fail("The selected corner no longer exists in this profile.");
        var previousIndex = (index + segments.Length - 1) % segments.Length;
        if (segments[previousIndex].Geometry is not LineArcLineSegment2D || segments[index].Geometry is not LineArcLineSegment2D)
            return Fail("This corner is already finished or is curved. Choose a different straight-sided corner.");
        var classification = ProfileJunctionClassifier.Classify(profile, loop).Single(j => j.SuccessorSegmentId == parts[2]).Classification;
        if (classification is not (ProfileJunctionKind.ConvexProfileJunction or ProfileJunctionKind.ReflexProfileJunction)) return Fail("Select a nondegenerate corner between two straight sides.");
        var previous = (LineArcLineSegment2D)segments[previousIndex].Geometry;
        var next = (LineArcLineSegment2D)segments[index].Geometry;
        LineArcProfileCurve2D replacement;
        if (kind == "Fillet")
        {
            var round = ProfileCornerRound.TryRound(previous, next, amount, out var reason);
            if (round is null) return Fail(reason ?? "This corner cannot be rounded.");
            previous = (LineArcLineSegment2D)round.Previous; next = (LineArcLineSegment2D)round.Next; replacement = round.Arc;
        }
        else
        {
            var a = Length(previous); var b = Length(next);
            if (Math.Min(a, b) - amount < Clearance) return Fail("The distance consumes an adjacent edge. Leave at least 0.01 mm of straight edge.");
            var start = (X: previous.End.X + (previous.Start.X - previous.End.X) * amount / a, Y: previous.End.Y + (previous.Start.Y - previous.End.Y) * amount / a);
            var end = (X: next.Start.X + (next.End.X - next.Start.X) * amount / b, Y: next.Start.Y + (next.End.Y - next.Start.Y) * amount / b);
            previous = previous with { End = start }; next = next with { Start = end }; replacement = new LineArcLineSegment2D(start, end);
        }
        if (Math.Min(Length(previous), Length(next)) < Clearance) return Fail("The size consumes an adjacent edge. Leave at least 0.01 mm of straight edge.");
        foreach (var other in segments.Where((_, i) => i != index && i != previousIndex).Select(s => s.Geometry))
            if (CurveDistance(replacement, other) < Clearance - 1e-8) return Fail("The finish reaches another boundary or finish. Reduce its size to retain at least 0.01 mm clearance.");
        segments[previousIndex] = segments[previousIndex] with { Geometry = previous };
        segments[index] = segments[index] with { Geometry = next };
        var name = declaration.Name!.Text;
        var added = new ResolvedProfileSegment2D(name, replacement,
            new("edgefinish:" + name, profile.Name, $"offset:{declaration.Span.Start}", "FullLength" + kind, profile.PlaneFrame));
        var result = profile with { Loops = [loop with { Segments = segments.Take(index).Concat([added]).Concat(segments.Skip(index)).ToArray() }] };
        var validation = ResolvedProfile2DValidator.Validate(result);
        return validation.IsValid ? new(result, name, kind, null, amount, target, classification == ProfileJunctionKind.ReflexProfileJunction) : Fail(string.Join("; ", validation.Diagnostics));
    }

    private static double Length(LineArcLineSegment2D l) => Hypot(l.End.X - l.Start.X, l.End.Y - l.Start.Y);
    private static double CurveDistance(LineArcProfileCurve2D a, LineArcProfileCurve2D b)
    {
        if (b is LineArcLineSegment2D line) return Distance(a, line);
        if (a is LineArcLineSegment2D otherLine) return Distance(b, otherLine);
        var first = (LineArcCircularArc2D)a; var second = (LineArcCircularArc2D)b;
        var candidates = new List<double>();
        foreach (var p in new[] { At(first, first.StartAngleRadians), At(first, first.StartAngleRadians + first.SweepAngleRadians) }) candidates.Add(PointArc(p, second));
        foreach (var p in new[] { At(second, second.StartAngleRadians), At(second, second.StartAngleRadians + second.SweepAngleRadians) }) candidates.Add(PointArc(p, first));
        var dx = second.Center.X - first.Center.X; var dy = second.Center.Y - first.Center.Y; var centers = Hypot(dx, dy);
        if (centers > 1e-12)
        {
            var angle = Math.Atan2(dy, dx);
            foreach (var signA in new[] { 0d, Math.PI }) foreach (var signB in new[] { 0d, Math.PI })
            {
                var p = At(first, angle + signA); var q = At(second, angle + signB);
                if (InArc(p, first) && InArc(q, second)) candidates.Add(Hypot(p.X - q.X, p.Y - q.Y));
            }
            var along = (first.Radius * first.Radius - second.Radius * second.Radius + centers * centers) / (2 * centers);
            var height2 = first.Radius * first.Radius - along * along;
            if (height2 >= -1e-10)
            {
                foreach (var sign in new[] { -1d, 1d })
                {
                    var h = sign * Math.Sqrt(Math.Max(0, height2));
                    var p = (X: first.Center.X + (along * dx - h * dy) / centers, Y: first.Center.Y + (along * dy + h * dx) / centers);
                    if (InArc(p, first) && InArc(p, second)) return 0;
                }
            }
        }
        return candidates.Min();
    }
    private static (double X, double Y) At(LineArcCircularArc2D arc, double angle) => (arc.Center.X + arc.Radius * Math.Cos(angle), arc.Center.Y + arc.Radius * Math.Sin(angle));
    private static bool InArc((double X, double Y) p, LineArcCircularArc2D arc)
    {
        var angle = Math.Atan2(p.Y - arc.Center.Y, p.X - arc.Center.X) - arc.StartAngleRadians;
        angle = arc.SweepAngleRadians > 0 ? (angle % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI) : -((-angle % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI));
        return Math.Abs(angle) <= Math.Abs(arc.SweepAngleRadians) + 1e-8;
    }
    private static double PointArc((double X, double Y) p, LineArcCircularArc2D arc)
    {
        if (InArc(p, arc)) return Math.Abs(Hypot(p.X - arc.Center.X, p.Y - arc.Center.Y) - arc.Radius);
        var start = At(arc, arc.StartAngleRadians); var end = At(arc, arc.StartAngleRadians + arc.SweepAngleRadians);
        return Math.Min(Hypot(p.X - start.X, p.Y - start.Y), Hypot(p.X - end.X, p.Y - end.Y));
    }
    private static double Hypot(double x, double y) => Math.Sqrt(x*x + y*y);
    private static double PointLine((double X, double Y) p, LineArcLineSegment2D l)
    {
        var dx = l.End.X-l.Start.X; var dy = l.End.Y-l.Start.Y;
        var t = Math.Clamp(((p.X-l.Start.X)*dx+(p.Y-l.Start.Y)*dy)/(dx*dx+dy*dy),0,1);
        return Hypot(p.X-l.Start.X-t*dx,p.Y-l.Start.Y-t*dy);
    }
    private static double Distance(LineArcProfileCurve2D curve, LineArcLineSegment2D line)
    {
        if (curve is LineArcLineSegment2D chord)
        {
            var ax=chord.End.X-chord.Start.X; var ay=chord.End.Y-chord.Start.Y;
            var bx=line.End.X-line.Start.X; var by=line.End.Y-line.Start.Y; var cross=ax*by-ay*bx;
            if (Math.Abs(cross)>1e-12) {
                var deltaX=line.Start.X-chord.Start.X; var deltaY=line.Start.Y-chord.Start.Y;
                var t=(deltaX*by-deltaY*bx)/cross; var u=(deltaX*ay-deltaY*ax)/cross;
                if (t>=0 && t<=1 && u>=0 && u<=1) return 0;
            }
            return new[] { PointLine(chord.Start,line),PointLine(chord.End,line),PointLine(line.Start,chord),PointLine(line.End,chord) }.Min();
        }
        var arc=(LineArcCircularArc2D)curve;
        (double X,double Y) At(double a)=>(arc.Center.X+arc.Radius*Math.Cos(a),arc.Center.Y+arc.Radius*Math.Sin(a));
        bool InArc((double X,double Y) p) {
            var a=Math.Atan2(p.Y-arc.Center.Y,p.X-arc.Center.X)-arc.StartAngleRadians;
            a=arc.SweepAngleRadians>0 ? (a%(2*Math.PI)+2*Math.PI)%(2*Math.PI) : -((-a%(2*Math.PI)+2*Math.PI)%(2*Math.PI));
            return Math.Abs(a)<=Math.Abs(arc.SweepAngleRadians)+1e-8;
        }
        var start=At(arc.StartAngleRadians); var end=At(arc.StartAngleRadians+arc.SweepAngleRadians);
        double PointArc((double X,double Y) p)=>InArc(p)?Math.Abs(Hypot(p.X-arc.Center.X,p.Y-arc.Center.Y)-arc.Radius)
            : Math.Min(Hypot(p.X-start.X,p.Y-start.Y),Hypot(p.X-end.X,p.Y-end.Y));
        var minimum=new[] { PointLine(start,line),PointLine(end,line),PointArc(line.Start),PointArc(line.End) }.Min();
        var dx=line.End.X-line.Start.X; var dy=line.End.Y-line.Start.Y; var length2=dx*dx+dy*dy;
        var fx=line.Start.X-arc.Center.X; var fy=line.Start.Y-arc.Center.Y;
        var b=2*(fx*dx+fy*dy); var c=fx*fx+fy*fy-arc.Radius*arc.Radius; var disc=b*b-4*length2*c;
        if(disc>=0) foreach(var t in new[]{(-b-Math.Sqrt(disc))/(2*length2),(-b+Math.Sqrt(disc))/(2*length2)})
            if(t>=0 && t<=1 && InArc((line.Start.X+t*dx,line.Start.Y+t*dy))) return 0;
        var length=Math.Sqrt(length2);
        foreach(var sign in new[]{-1d,1d}) {
            var p=(X:arc.Center.X+sign*arc.Radius*(-dy)/length,Y:arc.Center.Y+sign*arc.Radius*dx/length);
            var t=((p.X-line.Start.X)*dx+(p.Y-line.Start.Y)*dy)/length2;
            if(t>=0 && t<=1 && InArc(p)) minimum=Math.Min(minimum,PointLine(p,line));
        }
        return minimum;
    }
}