| /* |
| * Copyright 2026 Google LLC |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| #ifndef skgpu_graphite_sparse_strips_CoverageTestUtils_DEFINED |
| #define skgpu_graphite_sparse_strips_CoverageTestUtils_DEFINED |
| |
| #include "include/core/SkPoint.h" |
| #include "include/core/SkString.h" |
| #include "include/private/SkTDArray.h" |
| #include "src/core/SkVx.h" |
| #include "src/gpu/graphite/sparse_strips/MSAA_LUT.h" |
| #include "src/gpu/graphite/sparse_strips/Polyline.h" |
| #include "src/gpu/graphite/sparse_strips/SparseStripsTypes.h" |
| #include "src/gpu/graphite/sparse_strips/Tiler.h" |
| #include "tests/Test.h" |
| #include "tests/graphite/sparse_strips/Oracle.h" |
| |
| #include <algorithm> |
| #include <cmath> |
| #include <cstdint> |
| #include <vector> |
| |
| namespace skgpu::graphite { |
| |
| class CoverageTestUtils { |
| public: |
| CoverageTestUtils() = delete; |
| |
| // Simplified point-in-polygon verification using Even-Odd rule. |
| static bool PointInPolygon(SkPoint pt, const Polyline& polyline) { |
| bool inside = false; |
| for (auto it = polyline.begin(); it != polyline.end(); ++it) { |
| auto [line, idx] = *it; |
| if ((line.p0.fY > pt.fY) != (line.p1.fY > pt.fY)) { |
| float t = (pt.fY - line.p0.fY) / (line.p1.fY - line.p0.fY); |
| float xInt = line.p0.fX + t * (line.p1.fX - line.p0.fX); |
| if (pt.fX < xInt) { |
| inside = !inside; |
| } |
| } |
| } |
| return inside; |
| } |
| |
| // Prints ASCII map diagnostic comparing expected polygon coverage against actual rasterized |
| // mask. |
| template <uint16_t kTileWidth, uint16_t kTileHeight> |
| static void PrintCoverageDiagnostics(skiatest::Reporter* reporter, |
| const Polyline& polyline, |
| const Tiles<kTileWidth, kTileHeight>& tiler, |
| int failX, |
| int failY, |
| const SkTDArray<uint8_t>& actualMasks, |
| size_t tileStartIdx) { |
| SkString out("\n--- FAILURE DIAGNOSTICS ---\n"); |
| AppendGeometryLines(&out, &polyline); |
| AppendTileIntersections(&out, &tiler); |
| AppendTileAsciiMap<kTileWidth, kTileHeight>( |
| &out, |
| failX, |
| failY, |
| &polyline, |
| [&](int px, int py, int sy, SkPoint cp) { return PointInPolygon(cp, polyline); }, |
| [&](int px, int py, int sy, uint16_t localX, uint16_t localY) { |
| size_t bufIdx = tileStartIdx + (localY * kTileWidth + localX); |
| return (bufIdx < static_cast<size_t>(actualMasks.size())) && |
| ((actualMasks[bufIdx] & (1 << sy)) != 0); |
| }); |
| INFOF(reporter, "%s", out.c_str()); |
| } |
| |
| // Prints ASCII map diagnostic comparing Oracle expected coverage against actual winding. |
| template <uint16_t kTileWidth, uint16_t kTileHeight> |
| static void PrintWindingDiagnostics(skiatest::Reporter* reporter, |
| const char* testName, |
| uint16_t tileStartX, |
| uint16_t tileStartY, |
| uint16_t px, |
| uint16_t py, |
| skvx::int8 actualWinding, |
| skvx::int8 oracleWinding, |
| const Polyline* polyline, |
| const Tiles<kTileWidth, kTileHeight>* tiler, |
| const SkTDArray<skvx::int8>& exactWindings, |
| uint32_t tileStartAlphaIdx, |
| ScanlineOracle8x* oracle) { |
| SkString out; |
| out.appendf("\n=== MISMATCH DIAGNOSTIC [%s] ===\n", testName); |
| out.appendf("Location: Tile(%d,%d), Pixel(%d,%d) [Global px=%u, py=%u]\n", |
| static_cast<int>(tileStartX / kTileWidth), |
| static_cast<int>(tileStartY / kTileHeight), |
| static_cast<int>(px - tileStartX), |
| static_cast<int>(py - tileStartY), |
| px, |
| py); |
| out.appendf("Actual Winding: [%d, %d, %d, %d, %d, %d, %d, %d]\n", |
| actualWinding[0], actualWinding[1], actualWinding[2], actualWinding[3], |
| actualWinding[4], actualWinding[5], actualWinding[6], actualWinding[7]); |
| out.appendf("Oracle Winding: [%d, %d, %d, %d, %d, %d, %d, %d]\n", |
| oracleWinding[0], oracleWinding[1], oracleWinding[2], oracleWinding[3], |
| oracleWinding[4], oracleWinding[5], oracleWinding[6], oracleWinding[7]); |
| |
| AppendGeometryLines(&out, polyline, px, py); |
| AppendTileIntersections(&out, tiler, tileStartX / kTileWidth, tileStartY / kTileHeight); |
| |
| std::vector<ScanlineOracle8x::RowWindingInterval> oracleIntervals; |
| int cachedRow = -1; |
| |
| AppendTileAsciiMap<kTileWidth, kTileHeight>( |
| &out, |
| tileStartX, |
| tileStartY, |
| polyline, |
| [&](int currX, int currY, int sy, SkPoint cp) { |
| if (oracle) { |
| if (cachedRow != currY) { |
| oracleIntervals = oracle->buildRowIntervals(currY); |
| cachedRow = currY; |
| } |
| skvx::int8 expW = |
| ScanlineOracle8x::GetOracleWinding(currX, oracleIntervals); |
| return (expW[sy] != 0); |
| } |
| return false; |
| }, |
| [&](int currX, int currY, int sy, uint16_t localX, uint16_t localY) { |
| uint32_t bufIdx = tileStartAlphaIdx + (localY * kTileWidth + localX); |
| return (bufIdx < static_cast<uint32_t>(exactWindings.size())) && |
| (exactWindings[bufIdx][sy] != 0); |
| }, |
| "Oracle Expected", |
| "Actual"); |
| INFOF(reporter, "%s", out.c_str()); |
| } |
| |
| private: |
| static void AppendGeometryLines(SkString* out, |
| const Polyline* polyline, |
| int nearPx = -1, |
| int nearPy = -1) { |
| if (!polyline) { |
| return; |
| } |
| if (nearPx < 0) { |
| out->append("Geometry Lines: {\n"); |
| for (auto it = polyline->begin(); it != polyline->end(); ++it) { |
| auto [l, idx] = *it; |
| out->appendf(" {{%f, %f}, {%f, %f}},\n", l.p0.fX, l.p0.fY, l.p1.fX, l.p1.fY); |
| } |
| out->append("}\n\n"); |
| } else { |
| out->append("Polyline Lines near pixel:\n"); |
| for (auto it = polyline->begin(); it != polyline->end(); ++it) { |
| auto [l, idx] = *it; |
| float minX = std::min(l.p0.fX, l.p1.fX); |
| float maxX = std::max(l.p0.fX, l.p1.fX); |
| float minY = std::min(l.p0.fY, l.p1.fY); |
| float maxY = std::max(l.p0.fY, l.p1.fY); |
| if (maxX >= nearPx - 1 && minX <= nearPx + 2 && maxY >= nearPy - 1 && |
| minY <= nearPy + 2) { |
| out->appendf(" Line %d: (%.2f, %.2f) -> (%.2f, %.2f)\n", |
| idx, l.p0.fX, l.p0.fY, l.p1.fX, l.p1.fY); |
| } |
| } |
| } |
| } |
| |
| template <uint16_t kTileWidth, uint16_t kTileHeight> |
| static void AppendTileIntersections(SkString* out, |
| const Tiles<kTileWidth, kTileHeight>* tiler, |
| int tileX = -1, |
| int tileY = -1) { |
| if (!tiler) { |
| return; |
| } |
| out->append("Tile Intersections:\n"); |
| for (const auto& tile : tiler->getTiles()) { |
| if (tileX < 0 || (tile.x == tileX && tile.y == tileY)) { |
| uint32_t mask = tile.intersectionMask(); |
| uint32_t lineIdx = tile.lineIdx(); |
| out->appendf(" Tile(%u,%u) Line %u Mask: %s\n", |
| tile.x, |
| tile.y, |
| lineIdx, |
| IntersectionBits::MaskToString(mask).c_str()); |
| } |
| } |
| } |
| |
| // Checks if a point is within threshold distance to any line in polyline. |
| static bool PointNearLine(SkPoint pt, const Polyline& polyline, float threshold) { |
| for (auto it = polyline.begin(); it != polyline.end(); ++it) { |
| auto [line, idx] = *it; |
| float l2 = (line.p0.fX - line.p1.fX) * (line.p0.fX - line.p1.fX) + |
| (line.p0.fY - line.p1.fY) * (line.p0.fY - line.p1.fY); |
| float dist = 0.0f; |
| if (l2 == 0.0f) { |
| float dx = pt.fX - line.p0.fX; |
| float dy = pt.fY - line.p0.fY; |
| dist = std::sqrt(dx * dx + dy * dy); |
| } else { |
| float t = std::max(0.0f, |
| std::min(1.0f, |
| ((pt.fX - line.p0.fX) * (line.p1.fX - line.p0.fX) + |
| (pt.fY - line.p0.fY) * (line.p1.fY - line.p0.fY)) / |
| l2)); |
| float projX = line.p0.fX + t * (line.p1.fX - line.p0.fX); |
| float projY = line.p0.fY + t * (line.p1.fY - line.p0.fY); |
| dist = std::sqrt((pt.fX - projX) * (pt.fX - projX) + |
| (pt.fY - projY) * (pt.fY - projY)); |
| } |
| if (dist <= threshold) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // Formats a side-by-side ASCII map comparing expected and actual tile coverage. |
| template <uint16_t kTileWidth, uint16_t kTileHeight, typename ExpectedFn, typename ActualFn> |
| static void AppendTileAsciiMap(SkString* out, |
| uint16_t tileStartX, |
| uint16_t tileStartY, |
| const Polyline* polyline, |
| ExpectedFn&& isExpectedActive, |
| ActualFn&& isActualActive, |
| const char* leftLabel = "Expected", |
| const char* rightLabel = "Actual") { |
| out->appendf("\nASCII Map Tile(%d,%d) [Left: %s | Right: %s]\n", |
| static_cast<int>(tileStartX / kTileWidth), |
| static_cast<int>(tileStartY / kTileHeight), |
| leftLabel, |
| rightLabel); |
| |
| SkString border("+"); |
| for (int x = 0; x < kTileWidth; ++x) { |
| border.append("----------------+"); |
| } |
| |
| for (uint16_t localY = 0; localY < kTileHeight; ++localY) { |
| uint16_t currY = tileStartY + localY; |
| out->appendf("%s %s\n", border.c_str(), border.c_str()); |
| |
| for (int sy = 0; sy < 8; ++sy) { |
| for (int side = 0; side < 2; ++side) { // 0: Left/Expected, 1: Right/Actual |
| out->append("|"); |
| for (uint16_t localX = 0; localX < kTileWidth; ++localX) { |
| uint16_t currX = tileStartX + localX; |
| for (int sx = 0; sx < 8; ++sx) { |
| SkPoint cp = {currX + (sx + 0.5f) / 8.0f, currY + (sy + 0.5f) / 8.0f}; |
| bool onLine = |
| polyline ? PointNearLine(cp, *polyline, 0.6f / 8.0f) : false; |
| bool active = |
| (side == 0) ? isExpectedActive(currX, currY, sy, cp) |
| : isActualActive(currX, currY, sy, localX, localY); |
| |
| if (MSAA_LUT<uint8_t>::kPattern[sy] == sx) { |
| out->append(active ? (onLine ? "*#" : " #") |
| : (onLine ? "*o" : " o")); |
| } else { |
| out->append(onLine ? "**" : " "); |
| } |
| } |
| out->append("|"); |
| } |
| if (side == 0) { |
| out->append(" "); |
| } |
| } |
| out->append("\n"); |
| } |
| } |
| out->appendf("%s %s\n", border.c_str(), border.c_str()); |
| } |
| }; |
| |
| } // namespace skgpu::graphite |
| |
| #endif // skgpu_graphite_sparse_strips_CoverageTestUtils_DEFINED |
