929 lines
32 KiB
Rust
929 lines
32 KiB
Rust
// 跳一跳图集自适应切片算法模块。
|
||
// 提供两种基于图像内容的自适应 cell 边界检测算法：
|
||
// - SeedRefinement: 种子点精修（默认），在固定网格分界线附近搜索 density 最低点。
|
||
// - ValleyDetection: 全谷检测，高斯平滑 + 自适应阈值 + 合并 + 滑窗选最优。
|
||
// 两种算法均参数化，支持任意 rows × cols 网格配置，默认 6×3。
|
||
|
||
use axum::http::StatusCode;
|
||
use image;
|
||
use serde_json::json;
|
||
|
||
use crate::{
|
||
http_error::AppError,
|
||
jump_hop::{
|
||
JumpHopTileAtlasSlice, JumpHopTileFaceSlice, JumpHopTileFaceSlices,
|
||
JUMP_HOP_CREATION_PROVIDER, JUMP_HOP_TILE_UV_FACE_COLS, JUMP_HOP_TILE_UV_FACE_ROWS,
|
||
crop_jump_hop_tile_texture_cell, jump_hop_tile_face_key_label,
|
||
jump_hop_tile_type_by_index,
|
||
},
|
||
openai_image_generation::DownloadedOpenAiImage,
|
||
};
|
||
use shared_contracts::jump_hop::JumpHopTileFaceKey;
|
||
|
||
/// 默认 tile 行数
|
||
pub(crate) const DEFAULT_TILE_ROWS: u32 = 6;
|
||
/// 默认 tile 列数
|
||
pub(crate) const DEFAULT_TILE_COLS: u32 = 3;
|
||
|
||
/// 自适应切片算法类型（控制 atlas 级 6×3 cell 网格检测）
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||
pub(crate) enum AtlasSliceAlgorithm {
|
||
/// 种子点精修：在固定网格分界线附近搜索 density 最低点（默认）
|
||
SeedRefinement,
|
||
/// 全谷检测：高斯平滑 + 自适应阈值 + 合并 + 滑窗选最优
|
||
ValleyDetection,
|
||
}
|
||
|
||
impl Default for AtlasSliceAlgorithm {
|
||
fn default() -> Self {
|
||
Self::SeedRefinement
|
||
}
|
||
}
|
||
|
||
/// 自适应 cell 网格检测结果
|
||
#[derive(Clone, Debug)]
|
||
pub(crate) struct AdaptiveCellGrid {
|
||
/// 行边界位置 [height]，长度 = rows + 1
|
||
pub row_boundaries: Vec<u32>,
|
||
/// 列边界位置 [width]，长度 = cols + 1
|
||
pub col_boundaries: Vec<u32>,
|
||
/// 使用的算法
|
||
#[allow(dead_code)]
|
||
pub algorithm: AtlasSliceAlgorithm,
|
||
}
|
||
|
||
// ============================================================================
|
||
// Density 计算
|
||
// ============================================================================
|
||
|
||
/// 从 RGBA 像素计算行投影 density（每行非透明像素占比）
|
||
pub(crate) fn compute_row_density(pixels: &[u8], width: u32, height: u32) -> Vec<f32> {
|
||
let w = width as usize;
|
||
let h = height as usize;
|
||
let stride = w * 4;
|
||
let mut density = vec![0.0f32; h];
|
||
let total = w as f32;
|
||
for y in 0..h {
|
||
let row_start = y * stride;
|
||
let mut content = 0u32;
|
||
for x in 0..w {
|
||
if pixels[row_start + x * 4 + 3] > 0 {
|
||
content += 1;
|
||
}
|
||
}
|
||
density[y] = content as f32 / total;
|
||
}
|
||
density
|
||
}
|
||
|
||
/// 从 RGBA 像素计算列投影 density（每列非透明像素占比）
|
||
pub(crate) fn compute_col_density(pixels: &[u8], width: u32, height: u32) -> Vec<f32> {
|
||
let w = width as usize;
|
||
let h = height as usize;
|
||
let stride = w * 4;
|
||
let mut density = vec![0.0f32; w];
|
||
let total = h as f32;
|
||
for x in 0..w {
|
||
let mut content = 0u32;
|
||
for y in 0..h {
|
||
if pixels[y * stride + x * 4 + 3] > 0 {
|
||
content += 1;
|
||
}
|
||
}
|
||
density[x] = content as f32 / total;
|
||
}
|
||
density
|
||
}
|
||
|
||
// ============================================================================
|
||
// 共享工具
|
||
// ============================================================================
|
||
|
||
/// 在 [seed-radius, seed+radius] 范围内找 density 最小值的 index
|
||
fn find_min_density_position(density: &[f32], seed: u32, radius: u32) -> u32 {
|
||
let lo = seed.saturating_sub(radius) as usize;
|
||
let hi = (seed + radius).min(density.len().saturating_sub(1) as u32) as usize;
|
||
if lo >= density.len() || lo > hi {
|
||
return seed;
|
||
}
|
||
let mut best = seed as usize;
|
||
let mut best_val = density[best.min(density.len() - 1)];
|
||
for i in lo..=hi {
|
||
if density[i] < best_val {
|
||
best_val = density[i];
|
||
best = i;
|
||
}
|
||
}
|
||
best as u32
|
||
}
|
||
|
||
/// 保证边界单调递增（禁止交叉）
|
||
fn enforce_monotonic(boundaries: &mut [u32]) {
|
||
for i in 1..boundaries.len() {
|
||
if boundaries[i] <= boundaries[i - 1] {
|
||
boundaries[i] = boundaries[i - 1] + 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// 算法 A: 种子点精修 (Seed Refinement)
|
||
// ============================================================================
|
||
|
||
/// 种子点精修：对每条固定网格分界线，在 ±radius 搜索窗口内找 density 最低点。
|
||
///
|
||
/// * `density` - 一维投影 density 序列
|
||
/// * `seeds` - 固定网格分界线位置（不含 0 和 max）
|
||
/// * `radius` - 搜索半径
|
||
///
|
||
/// 返回精修后的分界线位置（不含 0 和 max）。
|
||
pub(crate) fn refine_boundaries_seed(
|
||
density: &[f32],
|
||
seeds: &[u32],
|
||
radius: u32,
|
||
) -> Vec<u32> {
|
||
let mut refined = Vec::with_capacity(seeds.len());
|
||
for &seed in seeds {
|
||
let pos = find_min_density_position(density, seed, radius);
|
||
refined.push(pos);
|
||
}
|
||
enforce_monotonic(&mut refined);
|
||
refined
|
||
}
|
||
|
||
/// 种子点精修完整流程：计算 density → 生成种子 → 精修 → 组装边界
|
||
pub(crate) fn detect_cell_grid_seed(
|
||
pixels: &[u8],
|
||
width: u32,
|
||
height: u32,
|
||
rows: u32,
|
||
cols: u32,
|
||
) -> AdaptiveCellGrid {
|
||
let row_density = compute_row_density(pixels, width, height);
|
||
let col_density = compute_col_density(pixels, width, height);
|
||
|
||
let cell_height = (height / rows).max(1);
|
||
let cell_width = (width / cols).max(1);
|
||
let radius_row = (cell_height / 3).max(1);
|
||
let radius_col = (cell_width / 3).max(1);
|
||
|
||
let row_seeds: Vec<u32> = (1..rows).map(|i| i * height / rows).collect();
|
||
let col_seeds: Vec<u32> = (1..cols).map(|i| i * width / cols).collect();
|
||
|
||
let row_splits = refine_boundaries_seed(&row_density, &row_seeds, radius_row);
|
||
let col_splits = refine_boundaries_seed(&col_density, &col_seeds, radius_col);
|
||
|
||
let mut row_boundaries = vec![0u32];
|
||
row_boundaries.extend(row_splits);
|
||
row_boundaries.push(height);
|
||
|
||
let mut col_boundaries = vec![0u32];
|
||
col_boundaries.extend(col_splits);
|
||
col_boundaries.push(width);
|
||
|
||
AdaptiveCellGrid {
|
||
row_boundaries,
|
||
col_boundaries,
|
||
algorithm: AtlasSliceAlgorithm::SeedRefinement,
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// 算法 B: 谷检测 (Valley Detection)
|
||
// ============================================================================
|
||
|
||
/// 一维高斯平滑核
|
||
fn gaussian_smooth_1d(signal: &[f32], sigma: f32) -> Vec<f32> {
|
||
let n = signal.len();
|
||
if n == 0 {
|
||
return vec![];
|
||
}
|
||
let radius = (sigma * 3.0).ceil() as isize;
|
||
let mut kernel = Vec::new();
|
||
let mut kernel_sum = 0.0f32;
|
||
for i in -radius..=radius {
|
||
let w = (-(i as f32).powi(2) / (2.0 * sigma * sigma)).exp();
|
||
kernel.push(w);
|
||
kernel_sum += w;
|
||
}
|
||
for w in &mut kernel {
|
||
*w /= kernel_sum;
|
||
}
|
||
|
||
let mut result = vec![0.0f32; n];
|
||
for i in 0..n {
|
||
let mut acc = 0.0f32;
|
||
let mut w_sum = 0.0f32;
|
||
for (k, &w) in kernel.iter().enumerate() {
|
||
let idx = i as isize + k as isize - radius;
|
||
if idx >= 0 && idx < n as isize {
|
||
acc += signal[idx as usize] * w;
|
||
w_sum += w;
|
||
}
|
||
}
|
||
if w_sum > 0.0 {
|
||
result[i] = acc / w_sum;
|
||
}
|
||
}
|
||
result
|
||
}
|
||
|
||
/// 低于阈值的连续区间 → 候选谷列表
|
||
fn extract_valleys_below_threshold(
|
||
signal: &[f32],
|
||
threshold: f32,
|
||
) -> Vec<(usize, usize)> {
|
||
let n = signal.len();
|
||
let mut valleys = Vec::new();
|
||
let mut in_valley = false;
|
||
let mut start = 0usize;
|
||
|
||
for i in 0..n {
|
||
if signal[i] <= threshold {
|
||
if !in_valley {
|
||
start = i;
|
||
in_valley = true;
|
||
}
|
||
} else if in_valley {
|
||
valleys.push((start, i - 1));
|
||
in_valley = false;
|
||
}
|
||
}
|
||
if in_valley {
|
||
valleys.push((start, n - 1));
|
||
}
|
||
valleys
|
||
}
|
||
|
||
/// 合并间距 < min_gap 的相邻谷
|
||
fn merge_close_valleys(
|
||
valleys: &[(usize, usize)],
|
||
min_gap: usize,
|
||
) -> Vec<(usize, usize)> {
|
||
if valleys.is_empty() {
|
||
return vec![];
|
||
}
|
||
let mut merged = Vec::new();
|
||
let mut cur_start = valleys[0].0;
|
||
let mut cur_end = valleys[0].1;
|
||
|
||
for &(s, e) in &valleys[1..] {
|
||
if s - cur_end <= min_gap {
|
||
cur_end = e;
|
||
} else {
|
||
merged.push((cur_start, cur_end));
|
||
cur_start = s;
|
||
cur_end = e;
|
||
}
|
||
}
|
||
merged.push((cur_start, cur_end));
|
||
merged
|
||
}
|
||
|
||
/// 谷的几何中心
|
||
fn valley_centers(valleys: &[(usize, usize)]) -> Vec<u32> {
|
||
valleys.iter().map(|&(s, e)| ((s + e) / 2) as u32).collect()
|
||
}
|
||
|
||
/// 滑窗选最优 target_count 个谷：枚举连续组合，选间距最均匀的一组
|
||
fn select_spaced_valleys(
|
||
centers: &[u32],
|
||
expected_spacing: f32,
|
||
target_count: usize,
|
||
) -> Vec<u32> {
|
||
if centers.len() <= target_count {
|
||
return centers.to_vec();
|
||
}
|
||
let mut best_score = f32::MAX;
|
||
let mut best_centers = vec![];
|
||
|
||
for start in 0..=centers.len() - target_count {
|
||
let window = ¢ers[start..start + target_count];
|
||
let mut score = 0.0f32;
|
||
for i in 1..window.len() {
|
||
let ratio = (window[i] - window[i - 1]) as f32 / expected_spacing;
|
||
score += (ratio - 1.0).powi(2);
|
||
}
|
||
if score < best_score {
|
||
best_score = score;
|
||
best_centers = window.to_vec();
|
||
}
|
||
}
|
||
best_centers
|
||
}
|
||
|
||
/// 谷检测完整流程
|
||
pub(crate) fn refine_boundaries_valley(
|
||
density: &[f32],
|
||
expected_cell_count: u32,
|
||
expected_cell_size: f32,
|
||
total_length: u32,
|
||
) -> Result<Vec<u32>, &'static str> {
|
||
if expected_cell_count <= 1 {
|
||
return Ok(vec![]);
|
||
}
|
||
let expected_valleys = (expected_cell_count - 1) as usize;
|
||
|
||
// 步骤1: 高斯平滑
|
||
let sigma = expected_cell_size / 4.0;
|
||
let smoothed = gaussian_smooth_1d(density, sigma);
|
||
|
||
// 步骤2: 自适应阈值
|
||
let peak = smoothed.iter().cloned().fold(0.0f32, f32::max);
|
||
let threshold = f32::max(peak * 0.15, 0.02);
|
||
|
||
// 步骤3: 提取候选谷
|
||
let raw_valleys = extract_valleys_below_threshold(&smoothed, threshold);
|
||
if raw_valleys.is_empty() {
|
||
return Err("未检测到候选谷");
|
||
}
|
||
|
||
// 步骤4: 合并相邻谷
|
||
let min_gap = (expected_cell_size * 0.5) as usize;
|
||
let merged = merge_close_valleys(&raw_valleys, min_gap);
|
||
|
||
// 步骤5: 过滤窄噪声谷（宽度 < 3px）
|
||
let filtered: Vec<_> = merged
|
||
.into_iter()
|
||
.filter(|&(s, e)| e >= s && e - s >= 3)
|
||
.collect();
|
||
if filtered.is_empty() {
|
||
return Err("过滤后无有效谷");
|
||
}
|
||
|
||
let centers = valley_centers(&filtered);
|
||
|
||
// 步骤6: 候选太多时按谷深排序取 top
|
||
let candidates = if centers.len() > expected_valleys + 2 {
|
||
let mut scored: Vec<_> = filtered
|
||
.iter()
|
||
.map(|&(s, e)| {
|
||
let avg = smoothed[s..=e].iter().sum::<f32>() / (e - s + 1) as f32;
|
||
let depth = peak - avg;
|
||
(depth, (s + e) / 2)
|
||
})
|
||
.collect();
|
||
scored.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(std::cmp::Ordering::Equal));
|
||
scored.truncate(expected_valleys + 2);
|
||
let mut c: Vec<u32> = scored.into_iter().map(|(_, center)| center as u32).collect();
|
||
c.sort();
|
||
c
|
||
} else {
|
||
centers
|
||
};
|
||
|
||
// 步骤7: 滑窗选最优 expected_valleys 个
|
||
let selected = select_spaced_valleys(&candidates, expected_cell_size, expected_valleys);
|
||
|
||
// 步骤8: 校验间距合理性
|
||
let min_spacing = (expected_cell_size * 0.5) as u32;
|
||
let max_spacing = (expected_cell_size * 1.8) as u32;
|
||
for i in 1..selected.len() {
|
||
let gap = selected[i] - selected[i - 1];
|
||
if gap < min_spacing || gap > max_spacing {
|
||
return Err("谷间距异常");
|
||
}
|
||
}
|
||
// 首尾不能太靠边
|
||
let min_edge = (expected_cell_size / 3.0) as u32;
|
||
if selected[0] < min_edge || total_length - selected[selected.len() - 1] < min_edge {
|
||
return Err("谷太靠近边界");
|
||
}
|
||
|
||
Ok(selected)
|
||
}
|
||
|
||
/// 谷检测完整流程：计算 density → 谷检测 → 组装边界
|
||
pub(crate) fn detect_cell_grid_valley(
|
||
pixels: &[u8],
|
||
width: u32,
|
||
height: u32,
|
||
rows: u32,
|
||
cols: u32,
|
||
) -> Result<AdaptiveCellGrid, &'static str> {
|
||
let row_density = compute_row_density(pixels, width, height);
|
||
let col_density = compute_col_density(pixels, width, height);
|
||
|
||
let cell_height = (height / rows).max(1) as f32;
|
||
let cell_width = (width / cols).max(1) as f32;
|
||
|
||
let row_splits = refine_boundaries_valley(&row_density, rows, cell_height, height)?;
|
||
let col_splits = refine_boundaries_valley(&col_density, cols, cell_width, width)?;
|
||
|
||
let mut row_boundaries = vec![0u32];
|
||
row_boundaries.extend(row_splits);
|
||
row_boundaries.push(height);
|
||
|
||
let mut col_boundaries = vec![0u32];
|
||
col_boundaries.extend(col_splits);
|
||
col_boundaries.push(width);
|
||
|
||
Ok(AdaptiveCellGrid {
|
||
row_boundaries,
|
||
col_boundaries,
|
||
algorithm: AtlasSliceAlgorithm::ValleyDetection,
|
||
})
|
||
}
|
||
|
||
// ============================================================================
|
||
// 主入口：自适应切片
|
||
// ============================================================================
|
||
|
||
/// 使用自适应算法对洋红去背后的图集进行切片。
|
||
///
|
||
/// * `image` - 洋红去背后的图集图片
|
||
/// * `rows` - cell 行数（默认 6）
|
||
/// * `cols` - cell 列数（默认 3）
|
||
/// * `algorithm` - 自适应算法
|
||
pub(crate) fn slice_tile_atlas_adaptive(
|
||
image: &DownloadedOpenAiImage,
|
||
rows: u32,
|
||
cols: u32,
|
||
algorithm: AtlasSliceAlgorithm,
|
||
) -> Result<Vec<JumpHopTileAtlasSlice>, AppError> {
|
||
let source = image::load_from_memory(image.bytes.as_slice())
|
||
.map_err(|error| {
|
||
AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
|
||
"provider": JUMP_HOP_CREATION_PROVIDER,
|
||
"message": format!("跳一跳地板贴图图集解码失败：{error}"),
|
||
}))
|
||
})?
|
||
.to_rgba8();
|
||
let width = source.width();
|
||
let height = source.height();
|
||
let pixels = source.as_raw();
|
||
|
||
// 自适应检测 cell 网格
|
||
let grid = match algorithm {
|
||
AtlasSliceAlgorithm::SeedRefinement => {
|
||
detect_cell_grid_seed(pixels, width, height, rows, cols)
|
||
}
|
||
AtlasSliceAlgorithm::ValleyDetection => {
|
||
detect_cell_grid_valley(pixels, width, height, rows, cols)
|
||
.unwrap_or_else(|_| {
|
||
// 谷检测失败时回退到种子点精修
|
||
detect_cell_grid_seed(pixels, width, height, rows, cols)
|
||
})
|
||
}
|
||
};
|
||
|
||
if grid.row_boundaries.len() != (rows + 1) as usize
|
||
|| grid.col_boundaries.len() != (cols + 1) as usize
|
||
{
|
||
return Err(AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
|
||
"provider": JUMP_HOP_CREATION_PROVIDER,
|
||
"message": format!(
|
||
"自适应网格检测结果异常：期望 {}×{}，实际 {}×{}",
|
||
rows + 1,
|
||
cols + 1,
|
||
grid.row_boundaries.len(),
|
||
grid.col_boundaries.len(),
|
||
),
|
||
})));
|
||
}
|
||
|
||
let tile_count = (rows * cols) as usize;
|
||
let mut slices = Vec::with_capacity(tile_count);
|
||
let mut index = 0usize;
|
||
|
||
for row in 0..rows {
|
||
for col in 0..cols {
|
||
let x0 = grid.col_boundaries[col as usize];
|
||
let x1 = grid.col_boundaries[col as usize + 1];
|
||
let y0 = grid.row_boundaries[row as usize];
|
||
let y1 = grid.row_boundaries[row as usize + 1];
|
||
let tile_width = x1.saturating_sub(x0).max(1);
|
||
let tile_height = y1.saturating_sub(y0).max(1);
|
||
|
||
let faces = slice_jump_hop_tile_uv_faces_blob(
|
||
&source,
|
||
x0,
|
||
y0,
|
||
tile_width,
|
||
tile_height,
|
||
row,
|
||
col,
|
||
)?;
|
||
|
||
slices.push(JumpHopTileAtlasSlice {
|
||
tile_type: jump_hop_tile_type_by_index(index),
|
||
source_atlas_cell: format!("row-{}-col-{}", row + 1, col + 1),
|
||
faces,
|
||
});
|
||
index += 1;
|
||
}
|
||
}
|
||
|
||
Ok(slices)
|
||
}
|
||
|
||
// ============================================================================
|
||
// Cell 内 UV 面提取（与固定网格逻辑相同，接收 cell 边界参数）
|
||
// ============================================================================
|
||
|
||
fn slice_jump_hop_tile_uv_faces_adaptive(
|
||
source: &image::RgbaImage,
|
||
tile_x: u32,
|
||
tile_y: u32,
|
||
tile_width: u32,
|
||
tile_height: u32,
|
||
atlas_row: u32,
|
||
atlas_col: u32,
|
||
) -> Result<JumpHopTileFaceSlices, AppError> {
|
||
let face_side = (tile_width / JUMP_HOP_TILE_UV_FACE_COLS)
|
||
.min(tile_height / JUMP_HOP_TILE_UV_FACE_ROWS)
|
||
.max(1);
|
||
let uv_width = face_side.saturating_mul(JUMP_HOP_TILE_UV_FACE_COLS);
|
||
let uv_height = face_side.saturating_mul(JUMP_HOP_TILE_UV_FACE_ROWS);
|
||
let uv_x = tile_x.saturating_add(tile_width.saturating_sub(uv_width) / 2);
|
||
let uv_y = tile_y.saturating_add(tile_height.saturating_sub(uv_height) / 2);
|
||
|
||
Ok(JumpHopTileFaceSlices {
|
||
top: slice_jump_hop_tile_uv_face_adaptive(
|
||
source, uv_x, uv_y, face_side, atlas_row, atlas_col, JumpHopTileFaceKey::Top, 1, 0,
|
||
)?,
|
||
front: slice_jump_hop_tile_uv_face_adaptive(
|
||
source, uv_x, uv_y, face_side, atlas_row, atlas_col, JumpHopTileFaceKey::Front, 1, 1,
|
||
)?,
|
||
right: slice_jump_hop_tile_uv_face_adaptive(
|
||
source, uv_x, uv_y, face_side, atlas_row, atlas_col, JumpHopTileFaceKey::Right, 2, 1,
|
||
)?,
|
||
back: slice_jump_hop_tile_uv_face_adaptive(
|
||
source, uv_x, uv_y, face_side, atlas_row, atlas_col, JumpHopTileFaceKey::Back, 3, 1,
|
||
)?,
|
||
left: slice_jump_hop_tile_uv_face_adaptive(
|
||
source, uv_x, uv_y, face_side, atlas_row, atlas_col, JumpHopTileFaceKey::Left, 0, 1,
|
||
)?,
|
||
bottom: slice_jump_hop_tile_uv_face_adaptive(
|
||
source, uv_x, uv_y, face_side, atlas_row, atlas_col, JumpHopTileFaceKey::Bottom, 1, 2,
|
||
)?,
|
||
})
|
||
}
|
||
|
||
#[allow(clippy::too_many_arguments)]
|
||
fn slice_jump_hop_tile_uv_face_adaptive(
|
||
source: &image::RgbaImage,
|
||
uv_x: u32,
|
||
uv_y: u32,
|
||
face_side: u32,
|
||
atlas_row: u32,
|
||
atlas_col: u32,
|
||
face: JumpHopTileFaceKey,
|
||
face_col: u32,
|
||
face_row: u32,
|
||
) -> Result<JumpHopTileFaceSlice, AppError> {
|
||
let cleaned = crop_jump_hop_tile_texture_cell(
|
||
source,
|
||
uv_x.saturating_add(face_col.saturating_mul(face_side)),
|
||
uv_y.saturating_add(face_row.saturating_mul(face_side)),
|
||
face_side,
|
||
face_side,
|
||
);
|
||
let mut cursor = std::io::Cursor::new(Vec::new());
|
||
cleaned
|
||
.write_to(&mut cursor, image::ImageFormat::Png)
|
||
.map_err(|error| {
|
||
AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
|
||
"provider": JUMP_HOP_CREATION_PROVIDER,
|
||
"message": format!("跳一跳地板 UV 面贴图切割失败：{error}"),
|
||
}))
|
||
})?;
|
||
let face_label = jump_hop_tile_face_key_label(&face);
|
||
|
||
Ok(JumpHopTileFaceSlice {
|
||
face,
|
||
source_atlas_cell: format!(
|
||
"row-{}-col-{}/{}",
|
||
atlas_row + 1,
|
||
atlas_col + 1,
|
||
face_label
|
||
),
|
||
bytes: cursor.into_inner(),
|
||
})
|
||
}
|
||
|
||
// ============================================================================
|
||
// Blob + Gradient 驱动 UV 面切分
|
||
//
|
||
// 1. BFS 找主 blob，构造仅含 blob 的 cleaned 图像
|
||
// 2. 行/列 density → 平滑 → gradient → 8 边界
|
||
// 3. 3×3 block → 5 有效块 → Block(1,2) 拆分 → 6 块
|
||
// 4. 每块 max opaque rectangle → 缩放
|
||
// ============================================================================
|
||
|
||
const BLOB_ALPHA: u8 = 48;
|
||
const MIN_BLOB_AREA: usize = 64;
|
||
const GRAD_SMOOTH: usize = 3;
|
||
|
||
// ---- 1. BFS 主 blob + 构造 cleaned 图像 ----
|
||
|
||
fn build_cleaned_tile(
|
||
source: &image::RgbaImage,
|
||
tile_x: u32, tile_y: u32, tile_w: u32, tile_h: u32,
|
||
) -> Option<image::RgbaImage> {
|
||
let pixels = source.as_raw();
|
||
let sw = source.width() as usize;
|
||
let stride = sw * 4;
|
||
let total = (tile_w * tile_h) as usize;
|
||
let mut visited = vec![false; total];
|
||
let mut queue = Vec::<usize>::new();
|
||
let mut best_comp = Vec::<usize>::new();
|
||
|
||
let idx = |lx: u32, ly: u32| (ly * tile_w + lx) as usize;
|
||
|
||
for sy in 0..tile_h {
|
||
for sx in 0..tile_w {
|
||
let si = idx(sx, sy);
|
||
if visited[si] { continue; }
|
||
let go = (tile_y as usize + sy as usize) * stride + (tile_x as usize + sx as usize) * 4;
|
||
if pixels[go + 3] < BLOB_ALPHA { continue; }
|
||
|
||
queue.clear();
|
||
queue.push(si);
|
||
visited[si] = true;
|
||
let mut qi = 0;
|
||
while qi < queue.len() {
|
||
let cur = queue[qi]; qi += 1;
|
||
let cx = cur as u32 % tile_w;
|
||
let cy = cur as u32 / tile_w;
|
||
for (dx, dy) in [(1i32,0i32),(-1,0),(0,1),(0,-1)] {
|
||
let nx = cx as i32 + dx;
|
||
let ny = cy as i32 + dy;
|
||
if nx < 0 || nx >= tile_w as i32 || ny < 0 || ny >= tile_h as i32 { continue; }
|
||
let ni = idx(nx as u32, ny as u32);
|
||
if visited[ni] { continue; }
|
||
let ngo = (tile_y as usize + ny as usize) * stride + (tile_x as usize + nx as usize) * 4;
|
||
if pixels[ngo + 3] >= BLOB_ALPHA {
|
||
visited[ni] = true;
|
||
queue.push(ni);
|
||
}
|
||
}
|
||
}
|
||
let area = queue.len();
|
||
if area < MIN_BLOB_AREA { continue; }
|
||
if area > best_comp.len() {
|
||
best_comp = queue.clone();
|
||
}
|
||
}
|
||
}
|
||
|
||
if best_comp.is_empty() { return None; }
|
||
|
||
// 构造 cleaned 图像：仅含主 blob
|
||
let mut cleaned = image::RgbaImage::new(tile_w, tile_h);
|
||
for &pi in &best_comp {
|
||
let lx = pi as u32 % tile_w;
|
||
let ly = pi as u32 / tile_w;
|
||
let gx = tile_x + lx;
|
||
let gy = tile_y + ly;
|
||
let go = (gy as usize * sw + gx as usize) * 4;
|
||
cleaned.put_pixel(lx, ly, image::Rgba([pixels[go], pixels[go+1], pixels[go+2], pixels[go+3]]));
|
||
}
|
||
Some(cleaned)
|
||
}
|
||
|
||
// ---- 2. density + gradient → 边界 ----
|
||
|
||
fn smooth_1d(signal: &[f32], window: usize) -> Vec<f32> {
|
||
if signal.len() <= window { return signal.to_vec(); }
|
||
let hw = window / 2;
|
||
(0..signal.len()).map(|i| {
|
||
let lo = i.saturating_sub(hw);
|
||
let hi = (i + hw).min(signal.len() - 1);
|
||
let sum: f32 = signal[lo..=hi].iter().sum();
|
||
sum / (hi - lo + 1) as f32
|
||
}).collect()
|
||
}
|
||
|
||
fn gradient(signal: &[f32]) -> Vec<f32> {
|
||
if signal.len() < 2 { return vec![]; }
|
||
(0..signal.len()-1).map(|i| signal[i+1] - signal[i]).collect()
|
||
}
|
||
|
||
/// 在 gradient 中找最强上升沿 (positive) 和最强下降沿 (negative) 的位置。
|
||
/// 返回 (peak_idx_pos, peak_idx_neg) 中最显著的 4 个位置，按值大小排序。
|
||
struct GradPeak { idx: usize, val: f32 }
|
||
fn find_gradient_peaks(grad: &[f32], count: usize, min_sep: usize) -> Vec<GradPeak> {
|
||
if grad.len() < 2 { return vec![]; }
|
||
// 取绝对值后找局部极大
|
||
let abs_grad: Vec<f32> = grad.iter().map(|&g| g.abs()).collect();
|
||
let mut peaks: Vec<GradPeak> = (1..abs_grad.len()-1)
|
||
.filter(|&i| abs_grad[i] > abs_grad[i-1] && abs_grad[i] >= abs_grad[i+1] && abs_grad[i] > 0.0)
|
||
.map(|i| GradPeak { idx: i, val: grad[i] }) // 保留符号
|
||
.collect();
|
||
peaks.sort_by(|a, b| b.val.abs().partial_cmp(&a.val.abs()).unwrap_or(std::cmp::Ordering::Equal));
|
||
// 去重：间距小于 min_sep 的只保留最大者
|
||
let mut chosen = Vec::new();
|
||
for p in peaks {
|
||
if chosen.iter().all(|c: &GradPeak| (c.idx as isize - p.idx as isize).unsigned_abs() >= min_sep) {
|
||
chosen.push(p);
|
||
if chosen.len() >= count { break; }
|
||
}
|
||
}
|
||
chosen
|
||
}
|
||
|
||
/// 行 density → gradient → y₀,y₁,y₂,y₃
|
||
fn detect_row_boundaries(cleaned: &image::RgbaImage, tile_w: u32, tile_h: u32) -> Option<(u32,u32,u32,u32)> {
|
||
// 行 density
|
||
let mut row_density = Vec::with_capacity(tile_h as usize);
|
||
for y in 0..tile_h {
|
||
let mut cnt = 0u32;
|
||
for x in 0..tile_w {
|
||
if cleaned.get_pixel(x, y).0[3] >= BLOB_ALPHA { cnt += 1; }
|
||
}
|
||
row_density.push(cnt as f32 / tile_w as f32);
|
||
}
|
||
let smooth = smooth_1d(&row_density, GRAD_SMOOTH);
|
||
let grad = gradient(&smooth);
|
||
let peaks = find_gradient_peaks(&grad, 4, 4);
|
||
if peaks.len() < 2 { return None; }
|
||
|
||
// 分离正负
|
||
let pos: Vec<_> = peaks.iter().filter(|p| p.val > 0.0).collect();
|
||
let neg: Vec<_> = peaks.iter().filter(|p| p.val < 0.0).collect();
|
||
if pos.len() < 1 || neg.len() < 1 { return None; }
|
||
|
||
// y₁: 最强正峰（窄→宽）; y₂: 最强负峰（宽→窄）
|
||
let y1 = pos[0].idx as u32;
|
||
let y2 = neg[0].idx as u32;
|
||
let y0 = row_density.iter().position(|&d| d > 0.0).unwrap_or(0) as u32;
|
||
let y3 = (row_density.len() as u32).saturating_sub(
|
||
1 + row_density.iter().rev().position(|&d| d > 0.0).unwrap_or(0) as u32
|
||
) + 1;
|
||
|
||
if y1 < y0 + 2 || y2 <= y1 + 6 || y2 > y3.saturating_sub(2) { return None; }
|
||
Some((y0, y1, y2, y3))
|
||
}
|
||
|
||
/// 列高度 profile（每列 blob 的首次/末次行）→ gradient → x₀,x₁,x₂,x₃
|
||
fn detect_col_boundaries(cleaned: &image::RgbaImage, tile_w: u32, _tile_h: u32, y0: u32, y3: u32) -> Option<(u32,u32,u32,u32)> {
|
||
// 每列的 blob 高度
|
||
let mut col_height = Vec::with_capacity(tile_w as usize);
|
||
for x in 0..tile_w {
|
||
let first = (y0..y3).find(|&y| cleaned.get_pixel(x, y).0[3] >= BLOB_ALPHA);
|
||
let last = (y0..y3).rev().find(|&y| cleaned.get_pixel(x, y).0[3] >= BLOB_ALPHA);
|
||
col_height.push(
|
||
first.map_or(0.0, |f| {
|
||
let l = last.unwrap_or(f);
|
||
(l - f + 1) as f32 / (y3 - y0).max(1) as f32
|
||
})
|
||
);
|
||
}
|
||
let smooth = smooth_1d(&col_height, GRAD_SMOOTH);
|
||
let grad = gradient(&smooth);
|
||
let peaks = find_gradient_peaks(&grad, 4, 4);
|
||
if peaks.len() < 2 { return None; }
|
||
|
||
let pos: Vec<_> = peaks.iter().filter(|p| p.val > 0.0).collect();
|
||
let neg: Vec<_> = peaks.iter().filter(|p| p.val < 0.0).collect();
|
||
if pos.len() < 1 || neg.len() < 1 { return None; }
|
||
|
||
let x1 = pos[0].idx as u32;
|
||
let x2 = neg[0].idx as u32;
|
||
let x0 = col_height.iter().position(|&d| d > 0.0).unwrap_or(0) as u32;
|
||
let x3 = (tile_w as usize).saturating_sub(
|
||
1 + col_height.iter().rev().position(|&d| d > 0.0).unwrap_or(0)
|
||
) as u32 + 1;
|
||
|
||
if x1 < x0 + 2 || x2 <= x1 + 6 || x2 > x3.saturating_sub(2) { return None; }
|
||
Some((x0, x1, x2, x3))
|
||
}
|
||
|
||
// ---- 3. max opaque rectangle per block ----
|
||
|
||
/// 在 block 范围内基于 histogram 找最大全不透明矩形。
|
||
fn max_opaque_rect(
|
||
cleaned: &image::RgbaImage,
|
||
bx0: u32, by0: u32, bw: u32, bh: u32,
|
||
) -> Option<(u32, u32, u32, u32)> {
|
||
let mut heights = vec![0u32; bw as usize];
|
||
let mut best_area = 0u32;
|
||
let mut best = (0u32, 0u32, 1u32, 1u32);
|
||
|
||
for ly in 0..bh {
|
||
for lx in 0..bw {
|
||
if cleaned.get_pixel(bx0 + lx, by0 + ly).0[3] >= BLOB_ALPHA {
|
||
heights[lx as usize] += 1;
|
||
} else {
|
||
heights[lx as usize] = 0;
|
||
}
|
||
}
|
||
// histogram max rect
|
||
let mut stack: Vec<(u32, u32)> = Vec::new(); // (start_x, height)
|
||
for (x, &h) in heights.iter().enumerate() {
|
||
let x = x as u32;
|
||
let mut start = x;
|
||
while stack.last().map_or(false, |&(_, sh)| sh > h) {
|
||
let (sx, sh) = stack.pop().unwrap();
|
||
let area = sh * (x - sx);
|
||
if area > best_area {
|
||
best_area = area;
|
||
best = (bx0 + sx, by0 + ly - sh + 1, x - sx, sh);
|
||
}
|
||
start = sx;
|
||
}
|
||
if h > 0 && stack.last().map_or(true, |&(_, sh)| h > sh) {
|
||
stack.push((start, h));
|
||
}
|
||
}
|
||
let x = bw;
|
||
while let Some((sx, sh)) = stack.pop() {
|
||
let area = sh * (x - sx);
|
||
if area > best_area {
|
||
best_area = area;
|
||
best = (bx0 + sx, by0 + ly as u32 - sh + 1, x - sx, sh);
|
||
}
|
||
}
|
||
}
|
||
if best_area == 0 { None } else { Some(best) }
|
||
}
|
||
|
||
// ---- 4. 主编排 ----
|
||
|
||
fn slice_jump_hop_tile_uv_faces_blob(
|
||
source: &image::RgbaImage,
|
||
tile_x: u32, tile_y: u32, tile_w: u32, tile_h: u32,
|
||
atlas_row: u32, atlas_col: u32,
|
||
) -> Result<JumpHopTileFaceSlices, AppError> {
|
||
let fallback = || {
|
||
slice_jump_hop_tile_uv_faces_adaptive(source, tile_x, tile_y, tile_w, tile_h, atlas_row, atlas_col)
|
||
};
|
||
|
||
// Step 1: BFS 主 blob → cleaned 图像
|
||
let cleaned = match build_cleaned_tile(source, tile_x, tile_y, tile_w, tile_h) {
|
||
Some(c) => c,
|
||
None => return fallback(),
|
||
};
|
||
|
||
// Step 2: gradient 边界检测
|
||
let (y0, y1, y2, y3) = match detect_row_boundaries(&cleaned, tile_w, tile_h) {
|
||
Some(v) => v,
|
||
None => return fallback(),
|
||
};
|
||
let (x0, x1, x2, x3) = match detect_col_boundaries(&cleaned, tile_w, tile_h, y0, y3) {
|
||
Some(v) => v,
|
||
None => return fallback(),
|
||
};
|
||
|
||
// Step 3: 3×3 block → 5 有效块 + Block(1,2) 拆分 → 6 块
|
||
// blocks: (row, col): 0=Top, 1,0=Left, 1,1=Front, 1,2=Right+Back, 2=Bottom
|
||
let blocks: [(u32,u32,u32,u32); 5] = [
|
||
(x1, y0, x2 - x1, y1 - y0), // Top
|
||
(x0, y1, x1 - x0, y2 - y1), // Left
|
||
(x1, y1, x2 - x1, y2 - y1), // Front
|
||
(x2, y1, x3 - x2, y2 - y1), // Right+Back
|
||
(x1, y2, x2 - x1, y3 - y2), // Bottom
|
||
];
|
||
|
||
// Step 4: max opaque rectangle per block
|
||
let rect = |b: (u32,u32,u32,u32), name: &str| -> Result<(u32,u32,u32,u32), AppError> {
|
||
max_opaque_rect(&cleaned, b.0, b.1, b.2, b.3).ok_or_else(|| {
|
||
AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
|
||
"provider": JUMP_HOP_CREATION_PROVIDER,
|
||
"message": format!("blob gradient: {name} 面无有效内容"),
|
||
}))
|
||
})
|
||
};
|
||
|
||
let top = rect(blocks[0], "Top")?;
|
||
let left = rect(blocks[1], "Left")?;
|
||
let front = rect(blocks[2], "Front")?;
|
||
// Right+Back → 从中点拆分
|
||
let (rb_x0, rb_y0, rb_w, rb_h) = blocks[3];
|
||
let mid = rb_x0 + rb_w / 2;
|
||
let right_rect = rect((rb_x0, rb_y0, mid - rb_x0, rb_h), "Right")?;
|
||
let back_rect = rect((mid, rb_y0, rb_x0 + rb_w - mid, rb_h), "Back")?;
|
||
let bottom = rect(blocks[4], "Bottom")?;
|
||
|
||
// Step 5: crop (tile_local → global)
|
||
let global = |r: (u32,u32,u32,u32)| (tile_x + r.0, tile_y + r.1, r.2, r.3);
|
||
|
||
let mk = |r: (u32,u32,u32,u32), face: JumpHopTileFaceKey| -> Result<JumpHopTileFaceSlice, AppError> {
|
||
let (gx, gy, gw, gh) = global(r);
|
||
let cleaned_dyn = crop_jump_hop_tile_texture_cell(source, gx, gy, gw, gh);
|
||
let mut cursor = std::io::Cursor::new(Vec::new());
|
||
cleaned_dyn.write_to(&mut cursor, image::ImageFormat::Png).map_err(|e| {
|
||
AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
|
||
"provider": JUMP_HOP_CREATION_PROVIDER,
|
||
"message": format!("跳一跳地板 UV 面贴图切割失败：{e}"),
|
||
}))
|
||
})?;
|
||
let label = jump_hop_tile_face_key_label(&face);
|
||
Ok(JumpHopTileFaceSlice {
|
||
face,
|
||
source_atlas_cell: format!("row-{}-col-{}/{}", atlas_row + 1, atlas_col + 1, label),
|
||
bytes: cursor.into_inner(),
|
||
})
|
||
};
|
||
|
||
Ok(JumpHopTileFaceSlices {
|
||
top: mk(top, JumpHopTileFaceKey::Top)?,
|
||
left: mk(left, JumpHopTileFaceKey::Left)?,
|
||
front: mk(front, JumpHopTileFaceKey::Front)?,
|
||
right: mk(right_rect, JumpHopTileFaceKey::Right)?,
|
||
back: mk(back_rect, JumpHopTileFaceKey::Back)?,
|
||
bottom: mk(bottom, JumpHopTileFaceKey::Bottom)?,
|
||
})
|
||
}
|