Hi-Z 遮挡剔除：深度金字塔必须保留孔洞

namespace DepthLab;

public readonly record struct Rect(int X0, int Y0, int X1, int Y1);

public sealed class DepthPyramid
{
    private readonly List<float[,]> levels = [];
    private readonly bool reversed;
    public int Size { get; }
    public int LevelCount => levels.Count;

    public DepthPyramid(float[,] depth, bool reversed)
    {
        Size = depth.GetLength(0);
        if (Size == 0 || Size != depth.GetLength(1) || (Size & (Size - 1)) != 0)
            throw new ArgumentException("Depth must be a nonempty power-of-two square");
        foreach (float d in depth)
            if (!float.IsFinite(d) || d < 0 || d > 1)
                throw new ArgumentException("Depth must be finite and within [0,1]");
        this.reversed = reversed;
        levels.Add((float[,])depth.Clone());
        for (int size = Size / 2; size > 0; size /= 2)
            levels.Add(Reduce(levels[^1], size));
    }

    private float Farther(float a, float b) => reversed ? Math.Min(a, b) : Math.Max(a, b);

    private float[,] Reduce(float[,] source, int size)
    {
        var result = new float[size, size];
        for (int y = 0; y < size; y++)
            for (int x = 0; x < size; x++)
            {
                float d = reversed ? 1 : 0;
                for (int dy = 0; dy < 2; dy++)
                    for (int dx = 0; dx < 2; dx++)
                        d = Farther(d, source[y * 2 + dy, x * 2 + dx]);
                result[y, x] = d;
            }
        return result;
    }

    public float Bound(Rect rect, int level)
    {
        if (level < 0 || level >= levels.Count || rect.X0 < 0 || rect.Y0 < 0 ||
            rect.X1 > Size || rect.Y1 > Size || rect.X0 >= rect.X1 || rect.Y0 >= rect.Y1)
            throw new ArgumentException("Invalid rectangle or level");
        int span = 1 << level;
        float d = reversed ? 1 : 0;
        // 半开矩形向外覆盖到所有相交的粗层单元。
        for (int y = rect.Y0 / span; y <= (rect.Y1 - 1) / span; y++)
            for (int x = rect.X0 / span; x <= (rect.X1 - 1) / span; x++)
                d = Farther(d, levels[level][y, x]);
        return d;
    }

    public bool Occluded(Rect rect, int level, float nearest, float epsilon)
    {
        if (!float.IsFinite(nearest) || nearest < 0 || nearest > 1 ||
            !float.IsFinite(epsilon) || epsilon < 0)
            throw new ArgumentException("Invalid candidate depth or tolerance");
        float farthest = Bound(rect, level);
        return reversed ? nearest < farthest - epsilon : nearest > farthest + epsilon;
    }
}

using DepthLab;

var depth = new float[4, 4];
for (int y = 0; y < 4; y++)
    for (int x = 0; x < 4; x++) depth[y, x] = 0.2f;
depth[1, 1] = 1.0f;
var pyramid = new DepthPyramid(depth, false);
var full = new Rect(0, 0, 4, 4);
bool correctCull = pyramid.Occluded(full, 2, 0.6f, 0.001f);
bool wrongCull = 0.6f > 0.2f + 0.001f;
if (correctCull || !wrongCull)
    throw new Exception("Hole regression failed");
var onePixel = new Rect(0, 0, 1, 1);
if (!pyramid.Occluded(onePixel, 0, 0.6f, 0.001f) ||
    pyramid.Occluded(onePixel, 1, 0.6f, 0.001f))
    throw new Exception("Coarse coverage regression failed");

dotnet build "$LAB_DIR/DepthLab.csproj" -c Release --no-restore
dotnet run --project "$LAB_DIR/DepthLab.csproj" -c Release --no-build

build_exit=0 warnings=0 errors=0
normal_max=1.0 wrong_min=0.2 candidate_nearest=0.6 culled=False wrong_culled=True
reversed_min=0.0 candidate_nearest=0.4 culled=False
passed=12 failed=0 skipped=0 cases=76800 elapsed_ms=37.111
run_exit=0