树叶纹理缩小后变稀：Alpha Test 覆盖率的修正与离散边界

1 1 | 1 1
1 0 | 1 0
----+----
1 0 | 1 0
0 0 | 0 0

source=8/16 raw=0/4 corrected=2/4

namespace AlphaCoverageLab;

public readonly record struct CoverageFit(
    double Scale, int Hits, int Samples, double Target, double Error);

public static class AlphaCoverage
{
    public static int Count(double[] alpha, double cutoff, double scale = 1)
        => alpha.Count(a => Math.Min(1, a * scale) >= cutoff);

    public static double[] Reduce2x2(double[] alpha, int width, int height)
    {
        if (width <= 0 || height <= 0 || width % 2 != 0 || height % 2 != 0
            || (long)width * height != alpha.Length)
            throw new ArgumentException("Expected an even rectangular image.");
        Validate(alpha);
        var result = new double[alpha.Length / 4];
        for (int y = 0; y < height; y += 2)
        for (int x = 0; x < width; x += 2)
        {
            int i = y * width + x;
            result[(y / 2) * (width / 2) + x / 2] =
                (alpha[i] + alpha[i + 1] + alpha[i + width] + alpha[i + width + 1]) / 4;
        }
        return result;
    }

    public static CoverageFit Fit(double[] mip, int referenceHits,
        int referenceSamples, double cutoff, double maxScale = 4)
    {
        Validate(mip);
        if (referenceSamples <= 0 || referenceHits < 0 || referenceHits > referenceSamples
            || !double.IsFinite(cutoff) || cutoff <= 0 || cutoff > 1
            || !double.IsFinite(maxScale) || maxScale < 1 || maxScale > 16)
            throw new ArgumentException("Invalid coverage contract.");
        var candidates = new SortedSet<double> { 0, 1, maxScale };
        foreach (double a in mip.Where(a => a > 0))
        {
            double scale = cutoff / a;
            if (!double.IsFinite(scale) || scale > maxScale) continue;
            // 保证相等阈值在当前浮点运算中确实通过。
            while (a * scale < cutoff) scale = Math.BitIncrement(scale);
            if (scale <= maxScale) candidates.Add(scale);
        }
        long bestError = long.MaxValue;
        double bestScale = 1;
        int bestHits = 0;
        foreach (double scale in candidates)
        {
            int hits = Count(mip, cutoff, scale);
            long error = Math.Abs((long)hits * referenceSamples - (long)referenceHits * mip.Length);
            if (error > bestError || (error == bestError &&
                Math.Abs(scale - 1) >= Math.Abs(bestScale - 1))) continue;
            (bestError, bestScale, bestHits) = (error, scale, hits);
        }
        double target = (double)referenceHits / referenceSamples;
        return new(bestScale, bestHits, mip.Length, target,
            Math.Abs((double)bestHits / mip.Length - target));
    }

    private static void Validate(double[] alpha)
    {
        if (alpha.Length == 0 || alpha.Any(a => !double.IsFinite(a) || a < 0 || a > 1))
            throw new ArgumentException("Expected finite normalized alpha.");
    }
}

$ dotnet build "$LAB_DIR/AlphaCoverageLab.csproj" -c Release
Build succeeded. 0 Warning(s), 0 Error(s).
Exit code: 0; elapsed=12.02s

$ dotnet run --project "$LAB_DIR/AlphaCoverageLab.csproj" -c Release --no-build
passed=20 failed=0 skipped=0 samples=65536 elapsedMs=682.7125
cutoff=0.8 scale=1.0666666666666667 target=0.5 error=0
source=8/16 raw=0/4 corrected=2/4
tied: target=0.25 actual=0 error=0.25 scale=1
Exit code: 0