Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

5.2 KB
Raw Blame
using Aetheris.Kernel.Core.Math;

namespace Aetheris.Reconstruction;

public sealed record FieldRegularizationReport(
    int InputSingularities, int OutputSingularities, int CancelledNet,
    int RetainedFeatureFaces, int RetainedBoundaryFaces, int AcceptedIterations,
    double InputIndexSum, double OutputIndexSum, bool GlobalIndexPreserved,
    string Objective, string DeterministicPolicy);

/// <summary>
/// Bounded global relaxation of a four-fold tangent field. Boundary and high-curvature feature
/// samples are fixed. An iteration is admitted only when the detected global quarter-index sum
/// is preserved and singularity count does not increase.
/// </summary>
public static class CrossFieldRegularizer
{
    public static (IReadOnlyList<DifferentialSample> Field, FieldRegularizationReport Report) Regularize(
        TriangleSurfaceMesh mesh, IReadOnlyList<DifferentialSample> input, int maximumIterations = 8, double featureQuantile = .9)
    {
        ArgumentNullException.ThrowIfNull(mesh); ArgumentNullException.ThrowIfNull(input);
        if (input.Count != mesh.Triangles.Count) throw new ArgumentException("Field sample count must equal face count.", nameof(input));
        if (maximumIterations < 0 || maximumIterations > 100) throw new ArgumentOutOfRangeException(nameof(maximumIterations));
        if (!double.IsFinite(featureQuantile) || featureQuantile <= 0 || featureQuantile >= 1) throw new ArgumentOutOfRangeException(nameof(featureQuantile));
        var adjacency = Adjacency(mesh, out var boundaryFaces); var curvatures = input.Select(x => x.CurvatureProxy).Where(double.IsFinite).Order().ToArray();
        var threshold = curvatures.Length == 0 ? double.PositiveInfinity : curvatures[(int)Math.Clamp(Math.Ceiling(featureQuantile * curvatures.Length) - 1, 0, curvatures.Length - 1)];
        var featureFaces = input.Where(x => x.CurvatureProxy >= threshold && x.CurvatureProxy > 0).Select(x => x.TriangleIndex).ToHashSet();
        var current = input.ToArray(); var initial = QuadAtlasRecovery.DetectSingularitiesForRegularization(mesh, current); var currentSingularities = initial; var initialIndex = initial.Sum(x => x.QuarterIndex); var accepted = 0;
        for (var iteration = 0; iteration < maximumIterations; iteration++)
        {
            var next = (DifferentialSample[])current.Clone();
            for (var face = 0; face < next.Length; face++)
            {
                if (!current[face].DirectionKnown || boundaryFaces.Contains(face) || featureFaces.Contains(face)) continue;
                var normal = current[face].Normal; var anchor = current[face].CrossDirection; var sum = anchor * 2;
                foreach (var neighbor in adjacency[face]) if (current[neighbor].DirectionKnown)
                {
                    var projected = current[neighbor].CrossDirection - normal * current[neighbor].CrossDirection.Dot(normal); if (!projected.TryNormalize(out projected)) continue;
                    var perpendicular = normal.Cross(projected); if (!perpendicular.TryNormalize(out perpendicular)) continue;
                    var representative = new[] { projected, -projected, perpendicular, -perpendicular }.OrderByDescending(x => x.Dot(anchor)).First(); sum += representative;
                }
                sum -= normal * sum.Dot(normal); if (sum.TryNormalize(out sum)) next[face] = next[face] with { CrossDirection = sum, EvidenceClass = "Heuristic: globally relaxed with fixed boundary/feature constraints" };
            }
            var singularities = QuadAtlasRecovery.DetectSingularitiesForRegularization(mesh, next); var index = singularities.Sum(x => x.QuarterIndex);
            if (Math.Abs(index - initialIndex) > .125 || singularities.Count > currentSingularities.Count) break;
            current = next; currentSingularities = singularities; accepted++;
        }
        var outputIndex = currentSingularities.Sum(x => x.QuarterIndex);
        return (current, new(initial.Count, currentSingularities.Count, initial.Count - currentSingularities.Count, featureFaces.Count, boundaryFaces.Count, accepted,
            initialIndex, outputIndex, Math.Abs(initialIndex - outputIndex) <= .125,
            "principal-direction alignment + neighbor smoothness + fixed feature/boundary evidence + singularity sparsity",
            "synchronous quarter-equivalent averaging; admit only non-increasing defect count with preserved global detected index"));
    }

    private static int[][] Adjacency(TriangleSurfaceMesh mesh, out HashSet<int> boundaryFaces)
    {
        var edges = new Dictionary<(int, int), List<int>>();
        for (var f = 0; f < mesh.Triangles.Count; f++) foreach (var edge in mesh.Triangles[f].DirectedEdges())
        { var key = edge.A < edge.B ? (edge.A, edge.B) : (edge.B, edge.A); if (!edges.TryGetValue(key, out var faces)) edges[key] = faces = []; faces.Add(f); }
        var lists = Enumerable.Range(0, mesh.Triangles.Count).Select(_ => new HashSet<int>()).ToArray(); boundaryFaces = [];
        foreach (var faces in edges.Values) if (faces.Count == 1) boundaryFaces.Add(faces[0]); else for (var i = 0; i < faces.Count; i++) for (var j = i + 1; j < faces.Count; j++) { lists[faces[i]].Add(faces[j]); lists[faces[j]].Add(faces[i]); }
        return lists.Select(x => x.Order().ToArray()).ToArray();
    }
}