diff --git a/Extension/Rendering/Capture/Test/capture_tests.cpp b/Extension/Rendering/Capture/Test/capture_tests.cpp index 96b67ef3..f89b6a1b 100644 --- a/Extension/Rendering/Capture/Test/capture_tests.cpp +++ b/Extension/Rendering/Capture/Test/capture_tests.cpp @@ -14,8 +14,6 @@ #include #include -namespace dingosdk::capture { bool depth_mask(const PixelView&, Rect, Image&); } - // Captures without the game (reskate.capture): matting, resizing, the card, the file formats, and a // recording of a turning board or skater found, cut out and saved. // Run with the folder of the menu fonts (External/fonts) as the first argument to test the card too, @@ -452,7 +450,7 @@ void test_depth_cut() { } // The cut by the game's depth: a skater standing on a floor that curves away at the sides. Shoes only -// 3% nearer than the floor under them are kept (they went missing, 2026-10-24); the curved floor is +// 0.5% nearer than the floor under them are kept (they went missing, 2026-10-24); the curved floor is // not taken for the skater. void test_depth_cut_contact() { constexpr std::uint32_t w = 200, h = 150; @@ -482,7 +480,36 @@ void test_depth_cut_contact() { expect(floor == 0, "a backdrop curving away is not taken for the subject"); } + +// A wide shallow foreground and far depth outliers must not bias the floor fit, +// including the floor directly under the subject where sole recovery can grow. +void test_depth_cut_wide_and_far() { + constexpr std::uint32_t w=800,h=200; + for (bool far : {false,true}) { + std::vector depth(std::size_t{w}*h); + std::vector pixels(std::size_t{w}*h*4,90); + for (std::uint32_t y=0;y=300 && x<500 && y>=20 && y<130) d*=.6; + if (x>=200 && x<600 && y>=130 && y<140) d*=.97; + if (far && x>=650 && x<660) d=9000000; + depth[std::size_t{y}*w+x]=static_cast(1/d); + } + Image picture(w,h); + const PixelView frame{pixels.data(),w,h,w*4,true,reinterpret_cast(depth.data()),w*4}; + expect(depth_mask(frame,{0,0,w,h},picture),"wide subject has a depth cut-out"); + for (std::uint32_t y=130;y<140;++y) for (std::uint32_t x=205;x<595;++x) + expect(picture.at(x,y)[3]==255,"wide 3%-nearer shoes survive a curved floor fit"); + for (std::uint32_t y=140;y(2, w * 6 / 100); std::vector distance(w), edge; std::vector aside(w), near_floor(std::size_t{w} * h); + std::vector intervals(std::size_t{w} + 1); float behind = 0; std::array fit{}; bool have_fit = false; @@ -62,27 +63,46 @@ bool depth_mask(const PixelView& frame, Rect area, Image& picture) { std::nth_element(edge.begin(), edge.begin() + static_cast(edge.size() / 2), edge.end()); behind = edge[edge.size() / 2]; } - // Set aside what is clearly in front, and a border round it. - std::fill(aside.begin(), aside.end(), std::uint8_t{0}); + // Expand foreground intervals in linear time rather than filling a + // wide border separately for every foreground pixel on the render thread. + std::fill(intervals.begin(), intervals.end(), 0); for (std::uint32_t x = 0; x < w; ++x) - if (distance[x] > 0 && behind > 0 && distance[x] < behind * 0.92f) - for (auto k = x > border ? x - border : 0u; k < std::min(w, x + border + 1); ++k) aside[k] = 1; - // Least squares a + b t + c t^2 over the rest, t across the row from -1 to 1 (Cramer's rule). - double s0 = 0, s1 = 0, s2 = 0, s3 = 0, s4 = 0, r0 = 0, r1 = 0, r2 = 0; + if (distance[x] > 0 && behind > 0 && distance[x] < behind * 0.92f) { + ++intervals[x > border ? x - border : 0u]; + --intervals[std::min(w, x + border + 1)]; + } + int covered = 0; for (std::uint32_t x = 0; x < w; ++x) { - if (aside[x] || distance[x] <= 0) continue; - const double t = (2.0 * x + 1) / w - 1, t2 = t * t, v = distance[x]; - s0 += 1, s1 += t, s2 += t2, s3 += t2 * t, s4 += t2 * t2, r0 += v, r1 += v * t, r2 += v * t2; + covered += intervals[x]; + aside[x] = covered != 0; } - const double det = s0 * (s2 * s4 - s3 * s3) - s1 * (s1 * s4 - s3 * s2) + s2 * (s1 * s3 - s2 * s2); - if (s0 >= w / 8.0 && std::abs(det) > 1e-9) { - fit[0] = (r0 * (s2 * s4 - s3 * s3) - s1 * (r1 * s4 - s3 * r2) + s2 * (r1 * s3 - s2 * r2)) / det; - fit[1] = (s0 * (r1 * s4 - r2 * s3) - r0 * (s1 * s4 - s3 * s2) + s2 * (s1 * r2 - r1 * s2)) / det; - fit[2] = (s0 * (s2 * r2 - s3 * r1) - s1 * (s1 * r2 - r1 * s2) + r0 * (s1 * s3 - s2 * s2)) / det; - have_fit = true; - } else if (behind > 0) { - fit = {behind, 0, 0}; // too little of the backdrop seen on this row: the outer columns' distance - have_fit = true; + // Anchor the initial curve to the outer backdrop, so wide shallow shoes + // cannot pull it towards themselves. Refine over the row only with + // samples agreeing with that anchor. Far props/holes never enter sums. + const auto solve = [&](bool edges_only, const std::array& reference) { + double s0=0,s1=0,s2=0,s3=0,s4=0,r0=0,r1=0,r2=0; + for (std::uint32_t x=0; xbehind*1.5) continue; + if (edges_only && x>=margin && xpredicted*.015)) continue; + s0+=1; s1+=t; s2+=t2; s3+=t2*t; s4+=t2*t2; r0+=value; r1+=value*t; r2+=value*t2; + } + const double det=s0*(s2*s4-s3*s3)-s1*(s1*s4-s3*s2)+s2*(s1*s3-s2*s2); + if (s0<6 || std::abs(det)<=1e-9) return false; + const std::array result{ + (r0*(s2*s4-s3*s3)-s1*(r1*s4-s3*r2)+s2*(r1*s3-s2*r2))/det, + (s0*(r1*s4-r2*s3)-r0*(s1*s4-s3*s2)+s2*(s1*r2-r1*s2))/det, + (s0*(s2*r2-s3*r1)-s1*(s1*r2-r1*s2)+r0*(s1*s3-s2*s2))/det}; + if (!std::all_of(result.begin(),result.end(),[](double v){return std::isfinite(v);})) return false; + fit=result; + have_fit=true; + return true; + }; + if (behind>0) { + fit={behind,0,0}; have_fit=true; + if (solve(true,fit)) { const auto anchor=fit; (void)solve(false,anchor); } } for (std::uint32_t x = 0; x < w; ++x) { const double t = (2.0 * x + 1) / w - 1;