Struct Det 

pub struct Det {
    pub params: DbParams,
    /* private fields */
}

载入好的检测模型。

Fields

params: DbParams

DB 后处理参数；缺省同参考实现，可按需调整。

Implementations

impl Det

pub fn load(dir: &Path) -> Result<Det, String>

dir 是模型目录：model.safetensors、config.json、preprocessor_config.json。

Examples found in repository

examples/det_check.rs (line 16)

fn main() {
    let a: Vec<String> = std::env::args().skip(1).collect();
    if a.len() < 5 || !(a.len() - 2).is_multiple_of(3) {
        eprintln!("用法：det_check <模型目录> <输出目录> <裸图> <宽> <高> ...");
        std::process::exit(2);
    }
    let t = Instant::now();
    let det = pagesift_ocr::det::Det::load(std::path::Path::new(&a[0])).unwrap();
    eprintln!("载入 {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
    let out_dir = std::path::Path::new(&a[1]);
    for c in a[2..].chunks(3) {
        let data = std::fs::read(&c[0]).unwrap();
        let (w, h): (usize, usize) = (c[1].parse().unwrap(), c[2].parse().unwrap());
        let channels = data.len() / (w * h);
        assert!(channels == 1 || channels == 3, "文件大小与宽高不符");
        let img = pagesift_ocr::Image {
            width: w,
            height: h,
            channels,
            data,
        };
        let name = std::path::Path::new(&c[0])
            .file_name()
            .unwrap()
            .to_string_lossy();
        let t = Instant::now();
        let (prob, pw, ph) = det.prob_map(&img).unwrap();
        let net_ms = t.elapsed().as_secs_f64() * 1e3;
        let boxes = det.boxes_from_prob(&prob, pw, ph, w, h);
        let ms = t.elapsed().as_secs_f64() * 1e3;
        eprintln!("{name}: 网络 {net_ms:.0} ms，后处理 {:.0} ms", ms - net_ms);
        // 设了 DET_DUMP_PROB 就把概率图另存成 8 位 PGM
        if std::env::var_os("DET_DUMP_PROB").is_some() {
            let mut pgm = format!("P5\n{pw} {ph}\n255\n").into_bytes();
            pgm.extend(prob.iter().map(|v| (v * 255.0).round() as u8));
            std::fs::write(out_dir.join(format!("{name}.prob.pgm")), pgm).unwrap();
        }
        let mut f = std::fs::File::create(out_dir.join(format!("{name}.boxes.txt"))).unwrap();
        for (q, s) in &boxes {
            for (x, y) in q {
                write!(f, "{x} {y} ").unwrap();
            }
            writeln!(f, "{s:.4}").unwrap();
        }
        eprintln!("{name}: {w}×{h}，{} 个框，{ms:.0} ms", boxes.len());
    }
}

pub fn prob_map(&self, page: &Image) -> Result<(Vec<f32>, usize, usize), String>

整页图 → 文字概率图（网络输入尺寸，按行存放）及其宽、高。

Examples found in repository

examples/det_check.rs (line 35)

fn main() {
    let a: Vec<String> = std::env::args().skip(1).collect();
    if a.len() < 5 || !(a.len() - 2).is_multiple_of(3) {
        eprintln!("用法：det_check <模型目录> <输出目录> <裸图> <宽> <高> ...");
        std::process::exit(2);
    }
    let t = Instant::now();
    let det = pagesift_ocr::det::Det::load(std::path::Path::new(&a[0])).unwrap();
    eprintln!("载入 {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
    let out_dir = std::path::Path::new(&a[1]);
    for c in a[2..].chunks(3) {
        let data = std::fs::read(&c[0]).unwrap();
        let (w, h): (usize, usize) = (c[1].parse().unwrap(), c[2].parse().unwrap());
        let channels = data.len() / (w * h);
        assert!(channels == 1 || channels == 3, "文件大小与宽高不符");
        let img = pagesift_ocr::Image {
            width: w,
            height: h,
            channels,
            data,
        };
        let name = std::path::Path::new(&c[0])
            .file_name()
            .unwrap()
            .to_string_lossy();
        let t = Instant::now();
        let (prob, pw, ph) = det.prob_map(&img).unwrap();
        let net_ms = t.elapsed().as_secs_f64() * 1e3;
        let boxes = det.boxes_from_prob(&prob, pw, ph, w, h);
        let ms = t.elapsed().as_secs_f64() * 1e3;
        eprintln!("{name}: 网络 {net_ms:.0} ms，后处理 {:.0} ms", ms - net_ms);
        // 设了 DET_DUMP_PROB 就把概率图另存成 8 位 PGM
        if std::env::var_os("DET_DUMP_PROB").is_some() {
            let mut pgm = format!("P5\n{pw} {ph}\n255\n").into_bytes();
            pgm.extend(prob.iter().map(|v| (v * 255.0).round() as u8));
            std::fs::write(out_dir.join(format!("{name}.prob.pgm")), pgm).unwrap();
        }
        let mut f = std::fs::File::create(out_dir.join(format!("{name}.boxes.txt"))).unwrap();
        for (q, s) in &boxes {
            for (x, y) in q {
                write!(f, "{x} {y} ").unwrap();
            }
            writeln!(f, "{s:.4}").unwrap();
        }
        eprintln!("{name}: {w}×{h}，{} 个框，{ms:.0} ms", boxes.len());
    }
}

pub fn preprocess(&self, page: &Image) -> Result<Tensor, String>

预处理整页图成网络输入 [3, H, W]。

pub fn prob_on<E: Exec>(&self, e: &E, x: &E::T) -> Result<E::T, String>

网络部分：[3, H, W] → [1, H, W] 的概率图，在执行器上算。

pub fn detect(&self, page: &Image) -> Result<Vec<Quad>, String>

检测整页图里的文字行，返回各行的四边形（原图像素坐标），从上到下、从左到右排好。

pub fn detect_scored(&self, page: &Image) -> Result<Vec<(Quad, f32)>, String>

同 Det::detect，并给出每个框的平均概率。

pub fn boxes_from_prob( &self, prob: &[f32], w: usize, h: usize, page_w: usize, page_h: usize, ) -> Vec<(Quad, f32)>

只做后处理：w × h 的概率图 → 原图（page_w × page_h）坐标下排好序的框和分数。

Examples found in repository

examples/det_check.rs (line 37)

fn main() {
    let a: Vec<String> = std::env::args().skip(1).collect();
    if a.len() < 5 || !(a.len() - 2).is_multiple_of(3) {
        eprintln!("用法：det_check <模型目录> <输出目录> <裸图> <宽> <高> ...");
        std::process::exit(2);
    }
    let t = Instant::now();
    let det = pagesift_ocr::det::Det::load(std::path::Path::new(&a[0])).unwrap();
    eprintln!("载入 {:.0} ms", t.elapsed().as_secs_f64() * 1e3);
    let out_dir = std::path::Path::new(&a[1]);
    for c in a[2..].chunks(3) {
        let data = std::fs::read(&c[0]).unwrap();
        let (w, h): (usize, usize) = (c[1].parse().unwrap(), c[2].parse().unwrap());
        let channels = data.len() / (w * h);
        assert!(channels == 1 || channels == 3, "文件大小与宽高不符");
        let img = pagesift_ocr::Image {
            width: w,
            height: h,
            channels,
            data,
        };
        let name = std::path::Path::new(&c[0])
            .file_name()
            .unwrap()
            .to_string_lossy();
        let t = Instant::now();
        let (prob, pw, ph) = det.prob_map(&img).unwrap();
        let net_ms = t.elapsed().as_secs_f64() * 1e3;
        let boxes = det.boxes_from_prob(&prob, pw, ph, w, h);
        let ms = t.elapsed().as_secs_f64() * 1e3;
        eprintln!("{name}: 网络 {net_ms:.0} ms，后处理 {:.0} ms", ms - net_ms);
        // 设了 DET_DUMP_PROB 就把概率图另存成 8 位 PGM
        if std::env::var_os("DET_DUMP_PROB").is_some() {
            let mut pgm = format!("P5\n{pw} {ph}\n255\n").into_bytes();
            pgm.extend(prob.iter().map(|v| (v * 255.0).round() as u8));
            std::fs::write(out_dir.join(format!("{name}.prob.pgm")), pgm).unwrap();
        }
        let mut f = std::fs::File::create(out_dir.join(format!("{name}.boxes.txt"))).unwrap();
        for (q, s) in &boxes {
            for (x, y) in q {
                write!(f, "{x} {y} ").unwrap();
            }
            writeln!(f, "{s:.4}").unwrap();
        }
        eprintln!("{name}: {w}×{h}，{} 个框，{ms:.0} ms", boxes.len());
    }
}