Rust高性能网格处理库jxl-grid使用指南

概述

jxl-grid是一个Rust语言的高性能网格处理库，提供了高效的网格数据结构和算法支持。它特别适合需要处理规则网格数据的应用场景，如科学计算、图像处理、游戏开发等领域。

主要特性

• 高性能的网格数据结构
• 内存高效的存储布局
• 支持多种网格算法
• 线程安全的设计
• 灵活的访问模式

安装

在Cargo.toml中添加依赖：

[dependencies]
jxl-grid = "0.3"

基本使用方法

创建网格

use jxl_grid::SimpleGrid;

// 创建一个10x10的f32类型网格
let mut grid = SimpleGrid::new(10, 10);

// 使用with_value创建并初始化所有值为1.0
let grid_with_values = SimpleGrid::with_value(10, 10, 1.0f32);

访问和修改网格数据

// 获取网格尺寸
let (width, height) = grid.size();

// 通过坐标访问元素
let value = grid.get(2, 3).unwrap();
grid.set(2, 3, 5.0f32).unwrap();

// 使用索引访问（更高效）
let idx = grid.idx(2, 3);
let value = grid[idx];
grid[idx] = 5.0f32;

网格操作示例

use jxl_grid::{SimpleGrid, Grid};

// 网格加法
fn add_grids(a: &SimpleGrid<f32>, b: &SimpleGrid<f32>) -> SimpleGrid<f32> {
    assert_eq!(a.size(), b.size());
    let mut result = SimpleGrid::new(a.width(), a.height());
    
    for y in 0..a.height() {
        for x in 0..a.width() {
            let idx = a.idx(x, y);
            result[idx] = a[idx] + b[idx];
        }
    }
    
    result
}

// 使用示例
let grid_a = SimpleGrid::with_value(5, 5, 2.0f32);
let grid_b = SimpleGrid::with_value(5, 5, 3.0f32);
let grid_c = add_grids(&grid_a, &grid_b);

高级功能：并行处理

use jxl_grid::SimpleGrid;
use rayon::prelude::*;

// 并行处理网格数据
fn parallel_process(grid: &mut SimpleGrid<f32>) {
    grid.par_iter_mut().for_each(|value| {
        *value = value.sqrt();
    });
}

let mut grid = SimpleGrid::with_value(1000, 1000, 4.0f32);
parallel_process(&mut grid);

网格卷积示例

use jxl_grid::{SimpleGrid, Grid};

fn convolve(
    input: &SimpleGrid<f32>,
    kernel: &SimpleGrid<f32>,
) -> SimpleGrid<f32> {
    let (kw, kh) = kernel.size();
    let (iw, ih) = input.size();
    let mut output = SimpleGrid::new(iw, ih);

    let k_center_x = kw / 2;
    let k_center_y = kh / 2;

    for y in 0..ih {
        for x in 0..iw {
            let mut sum = 0.0;

            for ky in 0..kh {
                let iy = y as isize + (ky as isize - k_center_y as isize);
                if iy < 0 || iy >= ih as isize {
                    continue;
                }

                for kx in 0..kw {
                    let ix = x as isize + (kx as isize - k_center_x as isize);
                    if ix < 0 || ix >= iw as isize {
                        continue;
                    }

                    let input_val = input.get(ix as usize, iy as usize).unwrap();
                    let kernel_val = kernel.get(kx, ky).unwrap();
                    sum += input_val * kernel_val;
                }
            }

            output.set(x, y, sum).unwrap();
        }
    }

    output
}

完整示例demo

下面是一个完整的jxl-grid使用示例，展示了从创建网格到进行各种操作的完整流程：

use jxl_grid::{SimpleGrid, Grid};
use rayon::prelude::*;

fn main() {
    // 1. 创建网格
    println!("创建网格...");
    let mut grid1 = SimpleGrid::new(5, 5);  // 5x5网格
    let grid2 = SimpleGrid::with_value(5, 5, 2.0f32);  // 所有值初始化为2.0
    
    // 2. 填充数据
    println!("填充数据...");
    for y in 0..5 {
        for x in 0..5 {
            let idx = grid1.idx(x, y);
            grid1[idx] = (x + y) as f32;
        }
    }
    
    // 3. 打印网格内容
    println!("网格1内容:");
    print_grid(&grid1);
    println!("网格2内容:");
    print_grid(&grid2);
    
    // 4. 网格加法
    println!("执行网格加法...");
    let sum_grid = add_grids(&grid1, &grid2);
    println!("求和结果:");
    print_grid(&sum_grid);
    
    // 5. 并行处理
    println!("并行处理网格...");
    let mut large_grid = SimpleGrid::with_value(100, 100, 16.0f32);
    parallel_process(&mut large_grid);
    
    // 检查部分结果
    println!("并行处理后部分结果:");
    for y in 0..3 {
        for x in 0..3 {
            let idx = large_grid.idx(x, y);
            print!("{:.2} ", large_grid[idx]);
        }
        println!();
    }
    
    // 6. 卷积操作
    println!("执行卷积操作...");
    let kernel = SimpleGrid::with_value(3, 3, 1.0f32 / 9.0f32);  // 平均滤波
    let convolved = convolve(&grid1, &kernel);
    println!("卷积结果:");
    print_grid(&convolved);
}

// 打印网格内容的辅助函数
fn print_grid(grid: &SimpleGrid<f32>) {
    let (width, height) = grid.size();
    for y in 0..height {
        for x in 0..width {
            print!("{:.1} ", grid.get(x, y).unwrap());
        }
        println!();
    }
    println!();
}

// 网格加法函数
fn add_grids(a: &SimpleGrid<f32>, b: &SimpleGrid<f32>) -> SimpleGrid<f32> {
    assert_eq!(a.size(), b.size());
    let mut result = SimpleGrid::new(a.width(), a.height());
    
    for y in 0..a.height() {
        for x in 0..a.width() {
            let idx = a.idx(x, y);
            result[idx] = a[idx] + b[idx];
        }
    }
    
    result
}

// 并行处理函数
fn parallel_process(grid: &mut SimpleGrid<f32>) {
    grid.par_iter_mut().for_each(|value| {
        *value = value.sqrt();
    });
}

// 卷积函数
fn convolve(input: &SimpleGrid<f32>, kernel: &SimpleGrid<f32>) -> SimpleGrid<f32> {
    let (kw, kh) = kernel.size();
    let (iw, ih) = input.size();
    let mut output = SimpleGrid::new(iw, ih);

    let k_center_x = kw / 2;
    let k_center_y = kh / 2;

    for y in 0..ih {
        for x in 0..iw {
            let mut sum = 0.0;

            for ky in 0..kh {
                let iy = y as isize + (ky as isize - k_center_y as isize);
                if iy < 0 || iy >= ih as isize {
                    continue;
                }

                for kx in 0..kw {
                    let ix = x as isize + (kx as isize - k_center_x as isize);
                    if ix < 0 || ix >= iw as isize {
                        continue;
                    }

                    let input_val = input.get(ix as usize, iy as usize).unwrap();
                    let kernel_val = kernel.get(kx, ky).unwrap();
                    sum += input_val * kernel_val;
                }
            }

            output.set(x, y, sum).unwrap();
        }
    }

    output
}

性能建议

1. 优先使用idx方法而不是get/set方法进行访问
2. 对于大型网格，考虑使用并行处理
3. 重用网格对象而不是频繁创建新对象
4. 使用适当的网格大小，避免频繁扩容

jxl-grid提供了强大的网格处理能力，通过合理使用可以显著提升涉及网格操作的应用程序性能。