AskaEth
31cb109445
P2-1：`TRACK_MIN_RUN = 200` 把「轨道被宿主裁短」这类几何回归从红变成绿——复审把 after 图里 0% 那条轨道右半截涂回画布色（连续段 160px）之后，那一行直接不成带，check_linear 靠另一条带 照样绿。现在拆成两条判据：成带阈值降到 **100**（实测：确定态行 318~320、不定态行 306~308、 文字行 22，两头都留得住），宽度**单独**判 ≥300（`TRACK_MIN_WIDTH`），不再藏在圆角检查的 find 里。反例复跑：两套主题都红「实测最宽段 160px @ 行 163」。 新增 `feedback/tests/bands.rs`（合成图，不依赖真实截图）两条用例，把两个阈值的取值区间钉住： 窄轨道必须仍成带且过不了宽度判据、22px 的文字段永远不成带。变异自证：调用点换回 `bands(.., 200)` → 两条用例都红（`left: [(12,15)] / right: [(5,8),(12,15)]`）； `TRACK_MIN_WIDTH=150` → 窄轨道用例红。 P2-2：订正两处写反的账——实测 `轨道带 2 条（高 [4, 5]）`，**两条带都在**厚度/宽度判据里 （5 行那条含 1 行抗锯齿，near 容 ±1），不是「只剩一条」；12.4 只量主色两段的左右端点， **不量**轨道厚度。根因（按单条 320 轨道心算 ~88px vs bands_by_run 按整行取 306px）已写进 `TRACK_MIN_RUN` 的文档。 顺带：12.1 的判据从 probe.rs 搬进 `probe/track.rs`——加完这几行 probe.rs 正好 401 行， 撞 400 红线；顺着 circular / panels 的先例一族几何一个文件。
348 lines
13 KiB
Rust
348 lines
13 KiB
Rust
//! 像素取证的小工具（**仅测试**）：读 PNG、按「底色 → 墨色」的覆盖率找连通块与长条。
|
||
//!
|
||
//! 为什么不复用 `gallery/scan.rs`：那个模块的可见性是
|
||
//! `pub(in crate::app::components::gallery)`，从家族目录拿不到（`selection/pixel.rs` 也是
|
||
//! 同样的理由自己写了一份）。这里只重写本家族真正用到的几个纯函数。
|
||
//!
|
||
//! **判据口径 1：覆盖率而不是精确色。** 4px 厚的进度条、28 圆角的卡片，边缘全是抗锯齿；
|
||
//! 按「精确色」连通会把它们切碎（实测进度条只剩中间 1~2 行）。
|
||
//! **判据口径 2：覆盖率 ≥50%。** 50% 是几何边界（30% 会把半格抗锯齿也算进去，4px 量成 6）。
|
||
|
||
use std::path::PathBuf;
|
||
|
||
use iced::Color;
|
||
|
||
/// 8bit RGB。
|
||
pub(super) fn rgb(color: Color) -> [u8; 3] {
|
||
[
|
||
(color.r * 255.0).round() as u8,
|
||
(color.g * 255.0).round() as u8,
|
||
(color.b * 255.0).round() as u8,
|
||
]
|
||
}
|
||
|
||
/// 容差比较（抗锯齿/取整）。
|
||
pub(super) fn matches(pixel: [u8; 3], expected: [u8; 3]) -> bool {
|
||
pixel.iter().zip(expected).all(|(a, b)| a.abs_diff(b) <= 10)
|
||
}
|
||
|
||
/// `ULL_GALLERY_SHOT` → 截图路径（相对路径按**工作区根**解释：`cargo test` 的 cwd 是 crate 目录）。
|
||
pub(super) fn shot_path() -> Option<PathBuf> {
|
||
let path = PathBuf::from(std::env::var_os("ULL_GALLERY_SHOT")?);
|
||
if path.is_absolute() || path.exists() {
|
||
return Some(path);
|
||
}
|
||
let root = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../..");
|
||
Some(root.join(path))
|
||
}
|
||
|
||
/// 一张图的像素访问器。
|
||
pub(super) struct Shot {
|
||
pub(super) width: usize,
|
||
pub(super) height: usize,
|
||
pixels: Vec<[u8; 3]>,
|
||
}
|
||
|
||
impl Shot {
|
||
pub(super) fn load(path: &std::path::Path) -> Result<Self, String> {
|
||
let bytes = std::fs::read(path).map_err(|error| format!("读不动 {path:?}：{error}"))?;
|
||
let image = image::load_from_memory(&bytes)
|
||
.map_err(|error| format!("解 PNG 失败：{error}"))?
|
||
.to_rgb8();
|
||
let (width, height) = (image.width() as usize, image.height() as usize);
|
||
Ok(Self {
|
||
width,
|
||
height,
|
||
pixels: image.pixels().map(|p| p.0).collect(),
|
||
})
|
||
}
|
||
|
||
pub(super) fn at(&self, x: usize, y: usize) -> [u8; 3] {
|
||
self.pixels[y * self.width + x]
|
||
}
|
||
|
||
/// **合成图**（不读盘）：按 `(x, y) → RGB` 造一张 `width × height` 的图。
|
||
///
|
||
/// 只给回归用例用：有些几何错误在真截图上**不会自然出现**（例如「轨道被宿主裁短」——
|
||
/// 真实渲染里轨道永远占满宿主，只有把像素涂掉才看得到，那是复审的一次性动作）。
|
||
/// 合成图让这类形状变成可复现的夹具，见 `tests/bands.rs`。
|
||
pub(super) fn from_rows(
|
||
width: usize,
|
||
height: usize,
|
||
pixel: impl Fn(usize, usize) -> [u8; 3],
|
||
) -> Self {
|
||
let mut pixels = Vec::with_capacity(width * height);
|
||
for y in 0..height {
|
||
for x in 0..width {
|
||
pixels.push(pixel(x, y));
|
||
}
|
||
}
|
||
Self {
|
||
width,
|
||
height,
|
||
pixels,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 一个外接框（闭区间）。
|
||
#[derive(Debug, Clone, Copy)]
|
||
pub(super) struct BBox {
|
||
pub(super) left: usize,
|
||
pub(super) right: usize,
|
||
pub(super) top: usize,
|
||
pub(super) bottom: usize,
|
||
}
|
||
|
||
impl BBox {
|
||
pub(super) fn new(x: usize, y: usize) -> Self {
|
||
Self {
|
||
left: x,
|
||
right: x,
|
||
top: y,
|
||
bottom: y,
|
||
}
|
||
}
|
||
|
||
pub(super) fn include(&mut self, x: usize, y: usize) {
|
||
self.left = self.left.min(x);
|
||
self.right = self.right.max(x);
|
||
self.top = self.top.min(y);
|
||
self.bottom = self.bottom.max(y);
|
||
}
|
||
|
||
pub(super) fn width(&self) -> usize {
|
||
self.right - self.left + 1
|
||
}
|
||
|
||
pub(super) fn height(&self) -> usize {
|
||
self.bottom - self.top + 1
|
||
}
|
||
}
|
||
|
||
/// 尺寸容差 ±1（rubric §6 的默认容差：控件常落在半像素上，实测会多一行抗锯齿）。
|
||
pub(super) fn near(value: usize, expected: usize) -> bool {
|
||
value.abs_diff(expected) <= 1
|
||
}
|
||
|
||
pub(super) fn dims(boxes: &[BBox]) -> String {
|
||
boxes
|
||
.iter()
|
||
.map(|bbox| format!("{}×{}", bbox.width(), bbox.height()))
|
||
.collect::<Vec<_>>()
|
||
.join(", ")
|
||
}
|
||
|
||
/// `pixel` 在「`under` → `fill`」这条混色线上的**覆盖率**（0..1；≥0.5 视为「算这块墨」）。
|
||
///
|
||
/// 投影到混色向量上取比例：抗锯齿像素正好落在 0..1 之间，另一种墨（文字、别的容器色）
|
||
/// 会落在线的两侧偏远处，比例被夹到 0 或 1 之外 → 用「偏离线距离」再筛一道。
|
||
pub(super) fn coverage(pixel: [u8; 3], fill: [u8; 3], under: [u8; 3]) -> f32 {
|
||
let axis = [0, 1, 2].map(|i| f32::from(fill[i]) - f32::from(under[i]));
|
||
let offset = [0, 1, 2].map(|i| f32::from(pixel[i]) - f32::from(under[i]));
|
||
let square: f32 = axis.iter().map(|a| a * a).sum();
|
||
if square <= f32::EPSILON {
|
||
return 0.0;
|
||
}
|
||
let t: f32 = (0..3).map(|i| axis[i] * offset[i]).sum::<f32>() / square;
|
||
let distance = (0..3)
|
||
.map(|i| (offset[i] - t * axis[i]).powi(2))
|
||
.sum::<f32>()
|
||
.sqrt();
|
||
// 8.0 而不是 16.0：深色填充（如 InverseSurface）与浅底之间的混色轴很长，深色**文字**
|
||
// （OnSurfaceVariant）投影上去残差只有 ≈9 —— 16 的阈值会把文字行算成填充，于是 48 高的
|
||
// 提示条被切成好几段（实测 46 + 1 + 1）。8.0 只排除文字，保留抗锯齿边（残差 0~3）。
|
||
if distance > 8.0 {
|
||
return 0.0;
|
||
}
|
||
t.clamp(0.0, 1.0)
|
||
}
|
||
|
||
/// 第 `y` 行上所有「算 `fill` 那块墨」的连续段 `(起点, 长度)`。
|
||
pub(super) fn runs(shot: &Shot, y: usize, fill: Color, under: Color) -> Vec<(usize, usize)> {
|
||
let (ink, base) = (rgb(fill), rgb(under));
|
||
let mut found = Vec::new();
|
||
let mut start: Option<usize> = None;
|
||
for x in 0..shot.width {
|
||
let hit = coverage(shot.at(x, y), ink, base) >= 0.5;
|
||
match (hit, start) {
|
||
(true, None) => start = Some(x),
|
||
(false, Some(from)) => {
|
||
found.push((from, x - from));
|
||
start = None;
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
if let Some(from) = start {
|
||
found.push((from, shot.width - from));
|
||
}
|
||
found
|
||
}
|
||
|
||
/// 一行里有多少「算 `fill` 那块墨」的像素（按覆盖率 ≥50% 判）。
|
||
///
|
||
/// 用**计数**而不是「最长段」：一条 344 宽的提示条，里面一行中文字会把它切成几段，
|
||
/// 按最长段判会把中间那些行漏掉（实测 48 高被切成 6 + 6 两段）。
|
||
pub(super) fn row_ink(shot: &Shot, y: usize, fill: Color, under: Color) -> usize {
|
||
let (ink, base) = (rgb(fill), rgb(under));
|
||
(0..shot.width)
|
||
.filter(|x| coverage(shot.at(*x, y), ink, base) >= 0.5)
|
||
.count()
|
||
}
|
||
|
||
/// 连续行里「墨量 ≥ `min_ink`」的那些行 → 聚成**竖带** `(top, bottom)`。
|
||
///
|
||
/// 用途：一条 4px 的进度条在图上就是「4 个连续行、每行都有 ~320 个墨点」；
|
||
/// 一个 48 高的提示条就是「48 个连续行」。比按精确色找 bbox 稳得多。
|
||
pub(super) fn bands(shot: &Shot, fill: Color, under: Color, min_ink: usize) -> Vec<(usize, usize)> {
|
||
let mut bands: Vec<(usize, usize)> = Vec::new();
|
||
let mut current: Option<usize> = None;
|
||
for y in 0..shot.height {
|
||
let hit = row_ink(shot, y, fill, under) >= min_ink;
|
||
match (hit, current) {
|
||
(true, None) => current = Some(y),
|
||
(false, Some(top)) => {
|
||
bands.push((top, y - 1));
|
||
current = None;
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
if let Some(top) = current {
|
||
bands.push((top, shot.height - 1));
|
||
}
|
||
bands
|
||
}
|
||
|
||
/// 竖带里最宽的一行的段长：取「每行最长连通段」的最大值。
|
||
///
|
||
/// 为什么要取最大而不是某一行：矩形控件上下有留白行（没文字），只有那几行量得到全宽；
|
||
/// 文字会把中间行切成几段。两条同色矩形并排时，`runs` 分别返回各自的长段，所以也不会串。
|
||
pub(super) fn band_width(shot: &Shot, band: (usize, usize), fill: Color, under: Color) -> usize {
|
||
(band.0..=band.1)
|
||
.map(|y| {
|
||
runs(shot, y, fill, under)
|
||
.into_iter()
|
||
.map(|(_, len)| len)
|
||
.max()
|
||
.unwrap_or(0)
|
||
})
|
||
.max()
|
||
.unwrap_or(0)
|
||
}
|
||
|
||
/// 按「**每行最长连续段** ≥ `min_run`」聚成的竖带。
|
||
///
|
||
/// 与 [`bands`] 的区别只在「一行算不算墨」的判法：`bands` 数**覆盖率 ≥50% 的像素个数**，
|
||
/// 本函数要求这些像素连成一长段。M248 换了进度轨道的角色之后，这个区别变成了分水岭：
|
||
///
|
||
/// - 轨道从强调色族（`SecondaryContainer`）改成中性容器面（`SurfaceContainerHighest`）后，
|
||
/// 「画布 → 轨道」这条混色轴**正好穿过中性文字与中性容器面**：文字像素的投影 `t` 会 clamp 到
|
||
/// 1.0、残差只剩 <8，于是整行文字都能被数成「轨道墨」（浅色板实测：命中行数从 2 条涨到 5 条，
|
||
/// 多出来的三条是图注文字，高度 6 / 2 / 6 行）；
|
||
/// - 按**连续段**判就不受影响：一行 12px 的字形边缘凑不出 200px 的连续同色段，而 360px 的轨道
|
||
/// 一眼就能认出来。
|
||
///
|
||
/// 阈值的取值口径：轨道带最窄的整段是 200px 以上（线性进度宿主 320/360 宽，指示条压在轨道上
|
||
/// 会把轨道切成几段，最长的那段仍 ≥200——不加指示条的确定态那一格是整条 360）。
|
||
pub(super) fn bands_by_run(
|
||
shot: &Shot,
|
||
fill: Color,
|
||
under: Color,
|
||
min_run: usize,
|
||
) -> Vec<(usize, usize)> {
|
||
let mut found: Vec<(usize, usize)> = Vec::new();
|
||
let mut current: Option<usize> = None;
|
||
for y in 0..shot.height {
|
||
let longest = runs(shot, y, fill, under)
|
||
.into_iter()
|
||
.map(|(_, len)| len)
|
||
.max()
|
||
.unwrap_or(0);
|
||
let hit = longest >= min_run;
|
||
match (hit, current) {
|
||
(true, None) => current = Some(y),
|
||
(false, Some(top)) => {
|
||
found.push((top, y - 1));
|
||
current = None;
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
if let Some(top) = current {
|
||
found.push((top, shot.height - 1));
|
||
}
|
||
found
|
||
}
|
||
|
||
/// 某种颜色的**精确色**连通块（只用于「找着一大块实心」这种粗定位）。
|
||
pub(super) fn blobs(shot: &Shot, color: Color, min_side: usize) -> Vec<BBox> {
|
||
let target = rgb(color);
|
||
let mut seen = vec![false; shot.width * shot.height];
|
||
let mut found = Vec::new();
|
||
for y in 0..shot.height {
|
||
for x in 0..shot.width {
|
||
if seen[y * shot.width + x] || !matches(shot.at(x, y), target) {
|
||
continue;
|
||
}
|
||
let mut stack = vec![(x, y)];
|
||
seen[y * shot.width + x] = true;
|
||
let mut bbox = BBox::new(x, y);
|
||
while let Some((cx, cy)) = stack.pop() {
|
||
bbox.include(cx, cy);
|
||
for (nx, ny) in [
|
||
(cx + 1, cy),
|
||
(cx.saturating_sub(1), cy),
|
||
(cx, cy + 1),
|
||
(cx, cy.saturating_sub(1)),
|
||
] {
|
||
let inside = nx < shot.width && ny < shot.height;
|
||
if inside && !seen[ny * shot.width + nx] && matches(shot.at(nx, ny), target) {
|
||
seen[ny * shot.width + nx] = true;
|
||
stack.push((nx, ny));
|
||
}
|
||
}
|
||
}
|
||
if bbox.width() >= min_side && bbox.height() >= min_side {
|
||
found.push(bbox);
|
||
}
|
||
}
|
||
}
|
||
found
|
||
}
|
||
|
||
/// 在 `bbox` 内找「最接近 `ink`（而不是 `under`）」的像素外接框（量文字/图标的内缩）。
|
||
pub(super) fn ink_inside(
|
||
shot: &Shot,
|
||
bbox: &BBox,
|
||
ink: Color,
|
||
under: Color,
|
||
margin: usize,
|
||
) -> Option<BBox> {
|
||
let (target, base) = (rgb(ink), rgb(under));
|
||
let mut found: Option<BBox> = None;
|
||
for y in (bbox.top + margin)..=(bbox.bottom.saturating_sub(margin)) {
|
||
for x in (bbox.left + margin)..=(bbox.right.saturating_sub(margin)) {
|
||
let pixel = shot.at(x, y);
|
||
let to_ink = pixel
|
||
.iter()
|
||
.zip(target)
|
||
.map(|(a, b)| u32::from(a.abs_diff(b)))
|
||
.sum::<u32>();
|
||
let to_base = pixel
|
||
.iter()
|
||
.zip(base)
|
||
.map(|(a, b)| u32::from(a.abs_diff(b)))
|
||
.sum::<u32>();
|
||
if to_ink < to_base {
|
||
match &mut found {
|
||
Some(bbox) => bbox.include(x, y),
|
||
None => found = Some(BBox::new(x, y)),
|
||
}
|
||
}
|
||
}
|
||
}
|
||
found
|
||
}
|