在终端中细分字体空间显示高清像素艺术的Rust实现求助

问题背景 #

刚入门Rust三周，计划开发终端小游戏并加入像素艺术元素。希望在终端中实现每个字符单元格展示4x8像素的效果（例如120x120像素画对应30x15的终端字符空间），且不使用平均颜色，保留像素画的真实细节。此前尝试过1x2的半块字符方案，但效果不佳且因平均色丢失细节，附尝试代码。使用Linux系统，询问该需求的可行性及解决方案。

尝试代码 #

use image::GenericImageView;
use crossterm::{terminal::{self, ClearType}, ExecutableCommand};
use std::io::{stdout, Write};

// Function to get the average color of a sub-region
fn average_color(img: &image::DynamicImage, x_start: u32, y_start: u32, width: u32, height: u32) -> [u8; 3] {
    let mut r_sum = 0;
    let mut g_sum = 0;
    let mut b_sum = 0;
    let mut count = 0;

    for y in y_start..y_start + height {
        for x in x_start..x_start + width {
            let pixel = img.get_pixel(x, y);
            let [r, g, b, _] = pixel.0;
            r_sum += r as u32;
            g_sum += g as u32;
            b_sum += b as u32;
            count += 1;
        }
    }

    [
        (r_sum / count) as u8,
        (g_sum / count) as u8,
        (b_sum / count) as u8,
    ]
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load the image
    let img = image::open("path_to_file.jpg")?;
    let (width, height) = img.dimensions();
    
    // Check the size of the image
    if width != 54 || height != 54 {
        eprintln!("L'image doit être de taille 50x50 !");
        return Ok(());
    }

    // Initialize the terminal
    let mut stdout = stdout();
    terminal::enable_raw_mode()?;
    stdout.execute(terminal::Clear(ClearType::All))?;

    // Define the size of each sub-region
    let sub_width = 1;
    let sub_height = 2;

    // Display each pixel
    for y in (0..height).step_by(sub_height as usize) {
        for x in (0..width).step_by(sub_width as usize) {
            // Get the average color for the top half of the character cell
            let top_color = average_color(&img, x, y, sub_width, sub_height);

            // Get the average color for the bottom half of the character cell
            let bottom_color = average_color(&img, x, y + sub_height / 2, sub_width, sub_height / 2);

            // Print the top half color
            print!("\x1b[38;2;{};{};{}m\x1b[48;2;{};{};{}m▀", bottom_color[0], bottom_color[1], bottom_color[2], top_color[0], top_color[1], top_color[2]);
        }
        // Move to the next line
        print!("\x1b[0m\r\n");
    }

    // Reset colors
    print!("\x1b[0m");
    stdout.flush()?;
    
    // Keep the terminal open until a key is pressed
    std::io::stdin().read_line(&mut String::new())?;

    // Disable raw mode in the terminal
    terminal::disable_raw_mode()?;

    Ok(())
}

可行性分析与解决方案 #

需求可行性 #

在Linux终端中，单个字符单元格仅支持1组前景色+1组背景色，无法直接在一个字符内显示4x8个独立颜色的像素，但可以通过Unicode特殊字符+颜色采样优化来近似实现需求，尽可能保留细节。

具体实现方案 #

方案1：优化半块字符方案，替换平均色为像素采样

放弃平均色计算，改为直接采样子区域的中心像素颜色，或取子区域内出现频率最高的主导色，避免细节丢失：

// 采样子区域中心像素的颜色
fn sample_center_color(img: &image::DynamicImage, x_start: u32, y_start: u32, width: u32, height: u32) -> [u8; 3] {
    let x = x_start + width / 2;
    let y = y_start + height / 2;
    let pixel = img.get_pixel(x, y);
    let [r, g, b, _] = pixel.0;
    [r, g, b]
}

// 统计子区域内的主导色（适合颜色种类少的像素画）
fn dominant_color(img: &image::DynamicImage, x_start: u32, y_start: u32, width: u32, height: u32) -> [u8; 3] {
    use std::collections::HashMap;
    let mut color_counts = HashMap::new();

    for y in y_start..y_start + height {
        for x in x_start..x_start + width {
            let pixel = img.get_pixel(x, y);
            let color = [pixel.0[0], pixel.0[1], pixel.0[2]];
            *color_counts.entry(color).or_insert(0) += 1;
        }
    }

    color_counts.into_iter().max_by_key(|&(_, count)| count).unwrap().0
}

将原代码中的average_color调用替换为sample_center_color或dominant_color，即可保留更多像素细节。

方案2：使用Braille盲文字符（2x4点阵）实现近似4x8像素展示

每个Braille字符包含2列4行的点阵，可表示8个像素的亮暗状态。结合真彩色，用每个Braille字符对应原图像的2x4像素区域，取该区域的主导色作为前景色，横向2个字符组成4像素宽，纵向2个字符组成8像素高，刚好对应需求的4x8像素/字符空间：

use image::GenericImageView;
use crossterm::{terminal::{self, ClearType}, ExecutableCommand};
use std::io::{stdout, Write};

// 将2x4像素区域转换为Braille字符及对应主导色
fn braille_from_pixels(img: &image::DynamicImage, x_start: u32, y_start: u32) -> (char, [u8; 3]) {
    let mut bits = 0u8;
    let mut color_counts = std::collections::HashMap::new();

    // 遍历2x4的像素区域
    for dy in 0..4 {
        for dx in 0..2 {
            let x = x_start + dx;
            let y = y_start + dy;
            let pixel = img.get_pixel(x, y);
            let color = [pixel.0[0], pixel.0[1], pixel.0[2]];
            *color_counts.entry(color).or_insert(0) += 1;

            // 用灰度值判断像素是否为“亮”（可根据需求调整阈值）
            let gray = (color[0] as u16 + color[1] as u16 + color[2] as u16) / 3;
            if gray > 127 {
                // 设置对应的Braille位
                let bit_pos = match (dx, dy) {
                    (0, 0) => 0,
                    (1, 0) => 1,
                    (0, 1) => 2,
                    (1, 1) => 3,
                    (0, 2) => 4,
                    (1, 2) => 5,
                    (0, 3) => 6,
                    (1, 3) => 7,
                    _ => unreachable!(),
                };
                bits |= 1 << bit_pos;
            }
        }
    }

    // 获取主导色
    let dominant_color = color_counts.into_iter().max_by_key(|&(_, count)| count).unwrap().0;
    // 计算Braille字符的码点
    let braille_char = char::from_u32(0x2800 + bits as u32).unwrap();

    (braille_char, dominant_color)
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let img = image::open("path_to_file.png")?; // 像素画建议用PNG格式避免压缩失真
    let (width, height) = img.dimensions();

    // 确保图像尺寸是4x8的倍数（对应30x15字符的话，尺寸应为120x120）
    if width % 4 != 0 || height % 8 != 0 {
        eprintln!("图像宽度必须是4的倍数，高度必须是8的倍数！");
        return Ok(());
    }

    let mut stdout = stdout();
    terminal::enable_raw_mode()?;
    stdout.execute(terminal::Clear(ClearType::All))?;

    // 遍历每个4x8的像素块
    for y_block in 0..(height / 8) {
        // 每个4x8块分为上下两个2x4的子块，对应两行Braille字符
        for dy in 0..2 {
            for x_block in 0..(width / 4) {
                // 每个4x8块分为左右两个2x4的子块，对应两个Braille字符
                for dx in 0..2 {
                    let x_start = x_block * 4 + dx * 2;
                    let y_start = y_block * 8 + dy * 4;
                    let (braille_char, color) = braille_from_pixels(&img, x_start, y_start);
                    // 设置前景色并打印字符
                    print!("\x1b[38;2;{};{};{}m{}", color[0], color[1], color[2], braille_char);
                }
            }
            print!("\x1b[0m\r\n");
        }
    }

    stdout.flush()?;
    std::io::stdin().read_line(&mut String::new())?;
    terminal::disable_raw_mode()?;

    Ok(())
}

该方案通过Braille字符的点阵还原像素亮暗，结合主导色保留颜色细节，能较好地在30x15的字符空间展示120x120的像素画。

内容的提问来源于stack exchange，提问作者Linux_96