Rust字体处理库typeface的使用，typeface提供高效的字体加载、解析和渲染功能

Typeface是一个用于构建和解析字体的基础库。它被用于opentype、postscript和truetype等项目中。

安装

在项目目录中运行以下Cargo命令：

cargo add typeface

或者在Cargo.toml中添加：

typeface = "0.5.0"

使用示例

以下是使用typeface库加载和解析字体文件的基本示例：

use typeface::{Font, FontCollection};
use std::fs::File;
use std::io::Read;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 打开字体文件
    let mut file = File::open("path/to/font.ttf")?;
    let mut buffer = Vec::new();
    file.read_to_end(&mut buffer)?;
    
    // 解析字体集合
    let collection = FontCollection::from_bytes(buffer)?;
    
    // 获取第一个字体
    if let Some(font) = collection.get(0) {
        // 获取字体基本信息
        println!("Font family: {}", font.family_name().unwrap_or("Unknown"));
        println!("Font weight: {:?}", font.weight());
        println!("Font style: {:?}", font.style());
        
        // 检查是否包含特定字符
        let char_to_check = 'A';
        if font.contains_char(char_to_check) {
            println!("Font contains character: {}", char_to_check);
            
            // 获取字符的度量信息
            if let Some(metrics) = font.char_metrics(char_to_check) {
                println!("Character metrics: {:?}", metrics);
            }
        }
    }
    
    Ok(())
}

更完整的示例

下面是一个更完整的示例，展示如何使用typeface加载字体并渲染简单的文本：

use typeface::{Font, FontCollection, RenderOptions};
use std::fs::File;
use std::io::Read;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 加载字体文件
    let mut font_file = File::open("path/to/font.ttf")?;
    let mut font_data = Vec::new();
    font_file.read_to_end(&mut font_data)?;
    
    // 解析字体
    let collection = FontCollection::from_bytes(font_data)?;
    let font = collection.get(0).ok_or("No fonts found in collection")?;
    
    // 设置渲染选项
    let options = RenderOptions {
        size: 24.0,        // 字体大小
        dpi: 96.0,         // DPI分辨率
        hinting: true,     // 启用字体提示
        ..Default::default()
    };
    
    // 渲染文本
    let text = "Hello, Typeface!";
    let mut x = 0.0;
    let y = 50.0;
    
    // 创建图像缓冲区
    let width = 500;
    let height = 100;
    let mut image = vec![0u8; width * height * 4];
    
    for c in text.chars() {
        if let Some(glyph) = font.render_char(c, &options) {
            // 将字形渲染到图像上
            for (i, pixel) in glyph.bitmap.iter().enumerate() {
                let row = i / glyph.width;
                let col = i % glyph.width;
                let x_pos = x as usize + col + glyph.left;
                let y_pos = y as usize + row - glyph.top;
                
                if x_pos < width && y_pos < height {
                    let index = (y_pos * width + x_pos) * 4;
                    image[index] = 255;       // R
                    image[index + 1] = 255;   // G
                    image[index + 2] = 255;   // B
                    image[index + 3] = *pixel; // A
                }
            }
            
            // 更新x位置
            x += glyph.advance.x as f32;
        }
    }
    
    // 在此处可以保存或显示图像...
    
    Ok(())
}

完整示例DEMO

下面是一个更完整的示例，展示如何使用typeface加载字体、查询字体信息并渲染文本到PNG图像：

use typeface::{Font, FontCollection, RenderOptions};
use std::fs::File;
use std::io::Read;
use std::path::Path;
use png::HasParameters;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 加载字体文件
    let font_path = "examples/NotoSans-Regular.ttf"; // 替换为你的字体路径
    let mut font_file = File::open(font_path)?;
    let mut font_data = Vec::new();
    font_file.read_to_end(&mut font_data)?;
    
    // 2. 解析字体集合
    let collection = FontCollection::from_bytes(font_data)?;
    let font = collection.get(0).ok_or("No fonts found in collection")?;
    
    // 3. 打印字体信息
    println!("=== 字体信息 ===");
    println!("字体家族: {}", font.family_name().unwrap_or("未知"));
    println!("权重: {:?}", font.weight());
    println!("样式: {:?}", font.style());
    println!("包含'A'字符: {}", font.contains_char('A'));
    
    // 4. 设置渲染选项
    let options = RenderOptions {
        size: 36.0,        // 更大的字体大小
        dpi: 144.0,       // 更高DPI
        hinting: true,    // 启用提示
        ..Default::default()
    };
    
    // 5. 渲染文本到图像
    let text = "Rust Typeface 中文测试";
    let mut x = 20.0;     // 起始X坐标
    let y = 60.0;         // 基线Y坐标
    
    // 创建RGBA图像缓冲区
    let width = 800;
    let height = 120;
    let mut image = vec![0u8; width * height * 4];
    
    // 设置背景色为浅灰色
    for pixel in image.chunks_exact_mut(4) {
        pixel[0] = 240; // R
        pixel[1] = 240; // G
        pixel[2] = 240; // B
        pixel[3] = 255; // A
    }
    
    // 渲染每个字符
    for c in text.chars() {
        if let Some(glyph) = font.render_char(c, &options) {
            // 将字形渲染到图像上
            for (i, pixel) in glyph.bitmap.iter().enumerate() {
                let row = i / glyph.width;
                let col = i % glyph.width;
                let x_pos = x as usize + col + glyph.left;
                let y_pos = y as usize + row - glyph.top;
                
                if x_pos < width && y_pos < height {
                    let index = (y_pos * width + x_pos) * 4;
                    // 设置黑色文本
                    image[index] = 0;       // R
                    image[index + 1] = 0;   // G
                    image[index + 2] = 0;   // B
                    image[index + 3] = *pixel; // A
                }
            }
            
            // 更新x位置
            x += glyph.advance.x as f32;
        }
    }
    
    // 6. 保存为PNG文件
    let output_path = "output.png";
    let path = Path::new(output_path);
    let file = File::create(path)?;
    let mut encoder = png::Encoder::new(file, width as u32, height as u32);
    encoder.set(png::ColorType::RGBA).set(png::BitDepth::Eight);
    let mut writer = encoder.write_header()?;
    writer.write_image_data(&image)?;
    
    println!("图像已保存到: {}", output_path);
    
    Ok(())
}

贡献

欢迎贡献代码！你可以提交issue或pull request。请注意，任何提交的贡献都将根据LICENSE.md中给出的条款进行许可。