Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

21.4 KB
Raw Blame
using System.Globalization;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using Aetheris.Kernel.Core.Brep;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Results;
using Aetheris.Kernel.Core.Step242;

namespace Aetheris.Sculpture;

public enum SculptureMode
{
    Virtual
}

public sealed record Sol1FrameDefinition(double MajorRadiusMm, double MinorRadiusMm, double ZMm);
public sealed record Sol1EyeDefinition(double MajorRadiusMm, double MinorRadiusMm, double ZMm);
public sealed record Sol1WaveDefinition(double PrimaryAmplitudeMm, double SecondaryAmplitudeMm, int AngularFrequency, double RadialFrequency);
public sealed record Sol1ProminenceDefinition(IReadOnlyList<int> Residues, int Modulus, double StartFraction, double RiseMm);
public sealed record Sol1LatticeDefinition(
    int NodeCount,
    double InnerRadiusMm,
    double OuterRadiusMm,
    double NodeRadiusMm,
    double StrandRadiusMm,
    IReadOnlyList<int> FibonacciOffsets,
    Sol1WaveDefinition Wave,
    Sol1ProminenceDefinition Prominences);

/// <summary>Canonical, bounded source contract for the ART-X0 flagship artwork.</summary>
public sealed record Sol1Definition(
    string Schema,
    string Id,
    string Title,
    SculptureMode Mode,
    Sol1FrameDefinition OuterFrame,
    Sol1EyeDefinition Eye,
    Sol1LatticeDefinition Lattice);

public sealed record Sol1Point(int Index, double RadiusMm, double ThetaRadians, Point3D Position, bool IsProminent);
public sealed record Sol1Connection(int From, int To, int FibonacciOffset, bool IsProminent, double LengthMm);

public sealed record Sol1RepresentationInventory(
    int Planes,
    int Cylinders,
    int Spheres,
    int Tori,
    int BSplineSurfaces,
    int RationalProductSurfaces);

public sealed record Sol1Evidence(
    string Milestone,
    string ArtworkId,
    string Title,
    SculptureMode Mode,
    string ConstructionLaw,
    double GoldenAngleRadians,
    int PhyllotaxisNodes,
    IReadOnlyList<int> FibonacciOffsets,
    int LatticeConnections,
    int ProminentNodes,
    int ProminentConnections,
    int ExactClosedBodyDefinitions,
    int ExactClosedBodyOccurrences,
    int AssemblyOccurrences,
    bool StepAssemblyReimportSucceeded,
    int ReimportedDefinitions,
    int ReimportedOccurrences,
    bool DeterministicSource,
    bool IsManufacturingGeometry,
    string Connectedness,
    Sol1RepresentationInventory SurfaceInventory,
    string StepSha256);

public sealed record Sol1Artifact(
    string Step,
    string PreviewSvg,
    Sol1Evidence Evidence,
    IReadOnlyList<Sol1Point> Points,
    IReadOnlyList<Sol1Connection> Connections);

public static class Sol1Source
{
    private static readonly JsonSerializerOptions JsonOptions = CreateOptions();

    public static KernelResult<Sol1Definition> Load(string path)
    {
        if (!File.Exists(path)) return Failure($"Sol 1 source was not found: {path}");
        try
        {
            var definition = JsonSerializer.Deserialize<Sol1Definition>(File.ReadAllText(path), JsonOptions);
            return definition is null ? Failure("Sol 1 source deserialized to null.") : Validate(definition);
        }
        catch (JsonException exception)
        {
            return Failure($"Sol 1 source is invalid JSON: {exception.Message}");
        }
    }

    public static KernelResult<Sol1Definition> Validate(Sol1Definition definition)
    {
        var errors = new List<string>();
        if (definition.Schema != "aetheris.virtual-sculpture/1") errors.Add("Schema must be 'aetheris.virtual-sculpture/1'.");
        if (definition.Id != "sol-1" || definition.Title != "Sol 1") errors.Add("ART-X0 admits only the flagship id/title 'sol-1'/'Sol 1'.");
        if (definition.Mode != SculptureMode.Virtual) errors.Add("Sol 1 must be explicitly marked Mode: Virtual.");
        if (!Positive(definition.OuterFrame.MajorRadiusMm) || !Positive(definition.OuterFrame.MinorRadiusMm) || definition.OuterFrame.MajorRadiusMm <= definition.OuterFrame.MinorRadiusMm)
            errors.Add("Outer frame radii must define a non-self-intersecting torus.");
        if (!Positive(definition.Eye.MajorRadiusMm) || !Positive(definition.Eye.MinorRadiusMm) || definition.Eye.MajorRadiusMm <= definition.Eye.MinorRadiusMm)
            errors.Add("Eye radii must define a non-self-intersecting torus.");
        var lattice = definition.Lattice;
        if (lattice.NodeCount is < 34 or > 610) errors.Add("NodeCount must remain in the bounded range 34..610.");
        if (!Positive(lattice.InnerRadiusMm) || !Positive(lattice.OuterRadiusMm) || lattice.OuterRadiusMm <= lattice.InnerRadiusMm)
            errors.Add("Lattice radii must be positive and ordered.");
        if (lattice.InnerRadiusMm <= definition.Eye.MajorRadiusMm + definition.Eye.MinorRadiusMm)
            errors.Add("The lattice must reserve a clean annular gap around the eye.");
        if (lattice.OuterRadiusMm + lattice.NodeRadiusMm >= definition.OuterFrame.MajorRadiusMm - definition.OuterFrame.MinorRadiusMm)
            errors.Add("The lattice must remain inside the exact outer frame.");
        if (!Positive(lattice.NodeRadiusMm) || !Positive(lattice.StrandRadiusMm) || lattice.StrandRadiusMm >= lattice.NodeRadiusMm)
            errors.Add("Node/strand radii must be positive, with strands smaller than nodes.");
        if (lattice.FibonacciOffsets.Count is < 1 or > 3 || lattice.FibonacciOffsets.Any(offset => offset <= 0 || offset >= lattice.NodeCount))
            errors.Add("One to three positive bounded Fibonacci offsets are required.");
        if (lattice.FibonacciOffsets.Distinct().Count() != lattice.FibonacciOffsets.Count) errors.Add("Fibonacci offsets must be unique.");
        if (!Positive(lattice.Wave.PrimaryAmplitudeMm) || lattice.Wave.SecondaryAmplitudeMm < 0d || lattice.Wave.AngularFrequency <= 0 || !double.IsFinite(lattice.Wave.RadialFrequency))
            errors.Add("Wave parameters must be finite and intentional.");
        var prominence = lattice.Prominences;
        if (prominence.Modulus <= 0 || prominence.Residues.Count is < 1 or > 5 || prominence.Residues.Any(r => r < 0 || r >= prominence.Modulus))
            errors.Add("Prominence residues must be a small valid subset of their modulus.");
        if (prominence.StartFraction is < 0.4 or >= 1d || !Positive(prominence.RiseMm)) errors.Add("Prominence rise must begin in the outer field and be positive.");
        return errors.Count == 0
            ? KernelResult<Sol1Definition>.Success(definition)
            : KernelResult<Sol1Definition>.Failure(errors.Select(message => new Aetheris.Kernel.Core.Diagnostics.KernelDiagnostic(
                Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed,
                Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error,
                message,
                "VirtualSculpture.Sol1.Source")).ToArray());
    }

    private static bool Positive(double value) => double.IsFinite(value) && value > 0d;
    private static KernelResult<Sol1Definition> Failure(string message) => KernelResult<Sol1Definition>.Failure([
        new(Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed,
            Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error,
            message,
            "VirtualSculpture.Sol1.Source")]);
    private static JsonSerializerOptions CreateOptions()
    {
        var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
        options.Converters.Add(new JsonStringEnumConverter());
        return options;
    }
}

/// <summary>
/// ART-X0's sole materializer. It produces a deterministic AP242 exact-body assembly:
/// analytic toroidal frame/eye, spherical phyllotaxis nodes, and cylindrical Fibonacci
/// parastichy chords. The multi-body structure is deliberate virtual sculpture semantics.
/// </summary>
public static class Sol1Materializer
{
    public const double GoldenAngleRadians = double.Pi * (3d - 2.2360679774997896964091736687313d);
    private const double LengthQuantumMm = 0.02d;

    public static KernelResult<Sol1Artifact> Build(Sol1Definition definition)
    {
        var validation = Sol1Source.Validate(definition);
        if (!validation.IsSuccess) return KernelResult<Sol1Artifact>.Failure(validation.Diagnostics);

        try
        {
            var points = GeneratePoints(definition);
            var connections = GenerateConnections(definition, points);
            var bodies = new Dictionary<string, BrepBody>(StringComparer.Ordinal);
            var definitions = new List<Step242AssemblyDefinition>();
            var occurrences = new List<Step242AssemblyOccurrence>();
            const string root = "virtual-sculpture:sol-1";
            occurrences.Add(new(root, "Sol 1", null, null, Identity()));

            AddBody("frame", "Sol 1 — exact outer calm", Require(BrepPrimitives.CreateTorus(definition.OuterFrame.MajorRadiusMm, definition.OuterFrame.MinorRadiusMm)));
            AddOccurrence("frame", "Outer analytic frame", TorusToXy(definition.OuterFrame.ZMm));
            AddBody("eye", "Sol 1 — central eye", Require(BrepPrimitives.CreateTorus(definition.Eye.MajorRadiusMm, definition.Eye.MinorRadiusMm)));
            AddOccurrence("eye", "Central analytic eye", TorusToXy(definition.Eye.ZMm));

            var haloMinor = definition.Lattice.StrandRadiusMm * 1.15d;
            var haloMajor = definition.Lattice.OuterRadiusMm + definition.Lattice.NodeRadiusMm + 0.75d;
            AddBody("halo", "Sol 1 — inner corona delimiter", Require(BrepPrimitives.CreateTorus(haloMajor, haloMinor)));
            AddOccurrence("halo", "Inner corona delimiter", TorusToXy(-0.65d));

            foreach (var point in points)
            {
                var kind = point.IsProminent ? "prominent-node" : "node";
                var radius = point.IsProminent ? definition.Lattice.NodeRadiusMm * 1.28d : definition.Lattice.NodeRadiusMm;
                if (!bodies.ContainsKey(kind)) AddBody(kind, point.IsProminent ? "Sol 1 — prominence bead" : "Sol 1 — phyllotaxis bead", Require(BrepPrimitives.CreateSphere(radius)));
                AddOccurrence(kind, $"Phyllotaxis n={point.Index:D3}", Translation(point.Position));
            }

            foreach (var connection in connections)
            {
                var radius = connection.IsProminent ? definition.Lattice.StrandRadiusMm * 1.5d : definition.Lattice.StrandRadiusMm;
                var length = Quantize(connection.LengthMm);
                var key = $"strand-r{Token(radius)}-l{Token(length)}";
                if (!bodies.ContainsKey(key)) AddBody(key, connection.IsProminent ? "Sol 1 — escaping parastichy segment" : "Sol 1 — Fibonacci parastichy segment", Require(BrepPrimitives.CreateCylinder(radius, length)));
                AddOccurrence(key, $"Fibonacci +{connection.FibonacciOffset}: {connection.From:D3}->{connection.To:D3}", SegmentTransform(points[connection.From].Position, points[connection.To].Position));
            }

            var export = Step242AssemblyExporter.Export(new("Sol 1", root, definitions, occurrences));
            if (!export.IsSuccess) return KernelResult<Sol1Artifact>.Failure(export.Diagnostics);
            var step = export.Value;
            var reimport = Step242AssemblyImporter.Import(step);
            if (!reimport.IsSuccess) return KernelResult<Sol1Artifact>.Failure(reimport.Diagnostics);

            var inventory = Inventory(step);
            if (inventory.RationalProductSurfaces != 0)
                return Failure("Sol 1 representation law violated: rational product surfaces were emitted.");

            var evidence = new Sol1Evidence(
                "ART-X0",
                definition.Id,
                definition.Title,
                definition.Mode,
                "r_n=sqrt(r_eye^2+n*(r_outer^2-r_eye^2)/(N-1)); theta_n=n*golden_angle; edges=(n,n+FibonacciOffset); z=two-frequency radial/angular wave plus three residue-selected outer prominence ramps",
                GoldenAngleRadians,
                points.Count,
                definition.Lattice.FibonacciOffsets,
                connections.Count,
                points.Count(point => point.IsProminent),
                connections.Count(connection => connection.IsProminent),
                definitions.Count,
                occurrences.Count - 1,
                occurrences.Count,
                true,
                reimport.Value.Definitions.Count,
                reimport.Value.Occurrences.Count,
                true,
                false,
                "Exact closed bodies are intentionally composed as an AP242 virtual-sculpture assembly. Overlapping node/strand occurrences create a perceptually continuous lattice without claiming a manufacturing boolean union.",
                inventory,
                Sha256(step));
            return KernelResult<Sol1Artifact>.Success(new(step, Sol1Preview.Render(definition, points, connections), evidence, points, connections));

            void AddBody(string stableId, string name, BrepBody body)
            {
                bodies.Add(stableId, body);
                definitions.Add(new($"sol-1:def:{stableId}", name, body));
            }
            void AddOccurrence(string definitionId, string name, IReadOnlyList<double> transform) => occurrences.Add(new(
                $"sol-1:occ:{occurrences.Count:D5}", name, root, $"sol-1:def:{definitionId}", transform));
        }
        catch (Exception exception) when (exception is ArgumentException or InvalidOperationException)
        {
            return Failure($"Sol 1 materialization failed: {exception.Message}");
        }
    }

    public static IReadOnlyList<Sol1Point> GeneratePoints(Sol1Definition definition)
    {
        var l = definition.Lattice;
        var result = new Sol1Point[l.NodeCount];
        for (var n = 0; n < l.NodeCount; n++)
        {
            var fraction = n / (double)(l.NodeCount - 1);
            var radius = double.Sqrt(l.InnerRadiusMm * l.InnerRadiusMm + fraction * (l.OuterRadiusMm * l.OuterRadiusMm - l.InnerRadiusMm * l.InnerRadiusMm));
            var theta = n * GoldenAngleRadians;
            var envelope = 0.22d + 0.78d * (1d - fraction);
            var z = l.Wave.PrimaryAmplitudeMm * envelope * double.Sin(l.Wave.AngularFrequency * theta + l.Wave.RadialFrequency * radius)
                + l.Wave.SecondaryAmplitudeMm * double.Sin(13d * theta - 0.11d * radius);
            var residue = n % l.Prominences.Modulus;
            var prominentFamily = l.Prominences.Residues.Contains(residue);
            var prominent = prominentFamily && fraction >= l.Prominences.StartFraction;
            if (prominent)
            {
                var u = (fraction - l.Prominences.StartFraction) / (1d - l.Prominences.StartFraction);
                var smooth = u * u * (3d - 2d * u);
                z += l.Prominences.RiseMm * smooth;
            }
            result[n] = new(n, radius, theta, new(radius * double.Cos(theta), radius * double.Sin(theta), z), prominent);
        }
        return result;
    }

    public static IReadOnlyList<Sol1Connection> GenerateConnections(Sol1Definition definition, IReadOnlyList<Sol1Point> points)
    {
        var result = new List<Sol1Connection>();
        foreach (var offset in definition.Lattice.FibonacciOffsets.Order())
            for (var from = 0; from + offset < points.Count; from++)
            {
                var to = from + offset;
                var prominent = offset == definition.Lattice.Prominences.Modulus && points[from].IsProminent && points[to].IsProminent;
                result.Add(new(from, to, offset, prominent, (points[to].Position - points[from].Position).Length));
            }
        return result;
    }

    private static BrepBody Require(KernelResult<BrepBody> result) => result.IsSuccess ? result.Value : throw new InvalidOperationException(string.Join("; ", result.Diagnostics.Select(d => d.Message)));
    private static double Quantize(double length) => double.Max(LengthQuantumMm, double.Round(length / LengthQuantumMm, MidpointRounding.AwayFromZero) * LengthQuantumMm);
    private static string Token(double value) => value.ToString("0.00", CultureInfo.InvariantCulture).Replace('.', '_');
    private static string Sha256(string value) => Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(value))).ToLowerInvariant();
    private static int Count(string text, string token) => (text.Length - text.Replace(token, string.Empty, StringComparison.Ordinal).Length) / token.Length;
    private static Sol1RepresentationInventory Inventory(string step) => new(
        Count(step, "=PLANE("),
        Count(step, "=CYLINDRICAL_SURFACE("),
        Count(step, "=SPHERICAL_SURFACE("),
        Count(step, "=TOROIDAL_SURFACE("),
        Count(step, "=B_SPLINE_SURFACE_WITH_KNOTS("),
        Count(step, "RATIONAL_B_SPLINE_SURFACE"));

    private static IReadOnlyList<double> Identity() => [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1];
    private static IReadOnlyList<double> Translation(Point3D point) => [1,0,0,0, 0,1,0,0, 0,0,1,0, point.X,point.Y,point.Z,1];
    private static IReadOnlyList<double> TorusToXy(double z) => [1,0,0,0, 0,0,1,0, 0,-1,0,0, 0,0,z,1];

    private static IReadOnlyList<double> SegmentTransform(Point3D a, Point3D b)
    {
        var delta = b - a;
        var zAxis = delta / delta.Length;
        var helper = double.Abs(zAxis.Z) < 0.9d ? new Vector3D(0, 0, 1) : new Vector3D(0, 1, 0);
        var xAxis = Cross(helper, zAxis);
        xAxis /= xAxis.Length;
        var yAxis = Cross(zAxis, xAxis);
        var center = new Point3D((a.X + b.X) / 2d, (a.Y + b.Y) / 2d, (a.Z + b.Z) / 2d);
        return [xAxis.X,xAxis.Y,xAxis.Z,0, yAxis.X,yAxis.Y,yAxis.Z,0, zAxis.X,zAxis.Y,zAxis.Z,0, center.X,center.Y,center.Z,1];
    }

    private static Vector3D Cross(Vector3D a, Vector3D b) => new(a.Y*b.Z-a.Z*b.Y, a.Z*b.X-a.X*b.Z, a.X*b.Y-a.Y*b.X);
    private static KernelResult<Sol1Artifact> Failure(string message) => KernelResult<Sol1Artifact>.Failure([
        new(Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed,
            Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error,
            message,
            "VirtualSculpture.Sol1.Materializer")]);
}

public static class Sol1Preview
{
    public static string Render(Sol1Definition definition, IReadOnlyList<Sol1Point> points, IReadOnlyList<Sol1Connection> connections)
    {
        const double size = 1200d;
        const double center = size / 2d;
        var scale = 500d / (definition.OuterFrame.MajorRadiusMm + definition.OuterFrame.MinorRadiusMm);
        var minZ = points.Min(p => p.Position.Z); var maxZ = points.Max(p => p.Position.Z);
        var builder = new StringBuilder();
        builder.AppendLine("<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"1200\" height=\"1200\" viewBox=\"0 0 1200 1200\">");
        builder.AppendLine("<defs><radialGradient id=\"bg\"><stop offset=\"0\" stop-color=\"#21120d\"/><stop offset=\"0.55\" stop-color=\"#090a12\"/><stop offset=\"1\" stop-color=\"#020308\"/></radialGradient><filter id=\"glow\"><feGaussianBlur stdDeviation=\"2.2\" result=\"b\"/><feMerge><feMergeNode in=\"b\"/><feMergeNode in=\"SourceGraphic\"/></feMerge></filter></defs>");
        builder.AppendLine("<rect width=\"1200\" height=\"1200\" fill=\"url(#bg)\"/><g filter=\"url(#glow)\" stroke-linecap=\"round\">");
        foreach (var edge in connections.OrderBy(edge => (points[edge.From].Position.Z + points[edge.To].Position.Z) / 2d))
        {
            var a = Project(points[edge.From].Position); var b = Project(points[edge.To].Position);
            var z = (points[edge.From].Position.Z + points[edge.To].Position.Z) / 2d;
            var t = (z - minZ) / double.Max(0.001d, maxZ - minZ);
            var color = edge.IsProminent ? "#fff3b0" : Blend(t);
            var width = edge.IsProminent ? 3.6d : 1.45d;
            builder.Append(CultureInfo.InvariantCulture, $"<line x1=\"{a.X:F2}\" y1=\"{a.Y:F2}\" x2=\"{b.X:F2}\" y2=\"{b.Y:F2}\" stroke=\"{color}\" stroke-width=\"{width:F2}\" opacity=\"0.92\"/>\n");
        }
        foreach (var point in points.OrderBy(point => point.Position.Z))
        {
            var p = Project(point.Position); var t = (point.Position.Z - minZ) / double.Max(0.001d, maxZ - minZ);
            var radius = point.IsProminent ? 5.1d : 3.0d;
            builder.Append(CultureInfo.InvariantCulture, $"<circle cx=\"{p.X:F2}\" cy=\"{p.Y:F2}\" r=\"{radius:F2}\" fill=\"{(point.IsProminent ? "#fff7cf" : Blend(t))}\"/>\n");
        }
        var outer = definition.OuterFrame.MajorRadiusMm * scale;
        var outerWidth = definition.OuterFrame.MinorRadiusMm * 2d * scale;
        var eye = definition.Eye.MajorRadiusMm * scale;
        var eyeWidth = definition.Eye.MinorRadiusMm * 2d * scale;
        builder.Append(CultureInfo.InvariantCulture, $"<circle cx=\"{center:F1}\" cy=\"{center:F1}\" r=\"{outer:F2}\" fill=\"none\" stroke=\"#ffd879\" stroke-width=\"{outerWidth:F2}\"/>\n");
        builder.Append(CultureInfo.InvariantCulture, $"<circle cx=\"{center:F1}\" cy=\"{center:F1}\" r=\"{eye:F2}\" fill=\"#03040a\" stroke=\"#fff0a3\" stroke-width=\"{eyeWidth:F2}\"/>\n");
        builder.AppendLine("</g><text x=\"600\" y=\"1140\" text-anchor=\"middle\" fill=\"#ffe6a0\" font-family=\"serif\" font-size=\"34\" letter-spacing=\"12\">SOL 1</text></svg>");
        return builder.ToString();

        (double X, double Y) Project(Point3D point) => (center + point.X * scale, center - point.Y * scale - point.Z * scale * 0.18d);
    }

    private static string Blend(double t)
    {
        t = double.Clamp(t, 0d, 1d);
        var r = (int)double.Round(220d + 35d * t);
        var g = (int)double.Round(82d + 157d * t);
        var b = (int)double.Round(31d + 120d * t);
        return $"#{r:X2}{g:X2}{b:X2}";
    }
}