k2f_pdf 0.2.2

K2F lock to PDF export
Documentation
use k2f_core::Rect;
use k2f_paint::{decode_raster, letterbox_dest, lookup_image};
use miniz_oxide::deflate::{compress_to_vec_zlib, CompressionLevel};
use pdf_writer::{Filter, Finish, Name, Pdf, Ref};
use std::collections::BTreeMap;

use crate::coord::pdf_y;
use crate::draw::PageDraw;
use crate::error::PdfError;
use crate::ids::Alloc;

pub struct ImageRes {
    pub id: Ref,
    pub name: String,
    pub w: u32,
    pub h: u32,
}

pub fn embed_rgb(
    pdf: &mut Pdf,
    alloc: &mut Alloc,
    w: u32,
    h: u32,
    rgb: &[u8],
    name: &str,
) -> ImageRes {
    let level = CompressionLevel::DefaultLevel as u8;
    let encoded = compress_to_vec_zlib(rgb, level);
    let id = alloc.bump();
    {
        let mut x = pdf.image_xobject(id, &encoded);
        x.filter(Filter::FlateDecode);
        x.width(w as i32);
        x.height(h as i32);
        x.color_space().device_rgb();
        x.bits_per_component(8);
        x.finish();
    }
    ImageRes {
        id,
        name: name.to_string(),
        w,
        h,
    }
}

pub fn embed_images(
    pdf: &mut Pdf,
    alloc: &mut Alloc,
    assets: &BTreeMap<String, Vec<u8>>,
    srcs: &[String],
) -> Result<BTreeMap<String, ImageRes>, PdfError> {
    let mut out = BTreeMap::new();
    for (i, src) in srcs.iter().enumerate() {
        if out.contains_key(src) {
            continue;
        }
        let bytes = lookup_image(assets, src)
            .ok_or_else(|| PdfError::Write(format!("missing image {src}")))?;
        let img = decode_raster(bytes)?;
        let rgb = img.to_rgb8();
        let level = CompressionLevel::DefaultLevel as u8;
        let encoded = compress_to_vec_zlib(rgb.as_raw(), level);
        let id = alloc.bump();
        let mask = img.color().has_alpha().then(|| alloc.bump());
        {
            let mut x = pdf.image_xobject(id, &encoded);
            x.filter(Filter::FlateDecode);
            x.width(img.width() as i32);
            x.height(img.height() as i32);
            x.color_space().device_rgb();
            x.bits_per_component(8);
            if let Some(m) = mask {
                x.s_mask(m);
            }
            x.finish();
        }
        if let Some(m) = mask {
            let alphas: Vec<u8> = img.to_rgba8().pixels().map(|p| p.0[3]).collect();
            let encoded = compress_to_vec_zlib(&alphas, level);
            let mut s = pdf.image_xobject(m, &encoded);
            s.filter(Filter::FlateDecode);
            s.width(img.width() as i32);
            s.height(img.height() as i32);
            s.color_space().device_gray();
            s.bits_per_component(8);
            s.finish();
        }
        out.insert(
            src.clone(),
            ImageRes {
                id,
                name: format!("Im{i}"),
                w: img.width(),
                h: img.height(),
            },
        );
    }
    Ok(out)
}

pub fn draw_image(
    page: &mut PageDraw,
    rect: &Rect,
    src: &str,
    images: &BTreeMap<String, ImageRes>,
) -> Result<(), PdfError> {
    let img = images
        .get(src)
        .ok_or_else(|| PdfError::Write(format!("image not embedded {src}")))?;
    page.note_image(rect);
    let box_w = rect.width.as_f64_pt().round().max(1.0) as u32;
    let box_h = rect.height.as_f64_pt().round().max(1.0) as u32;
    let (dx, dy, dw, dh) =
        letterbox_dest(img.w, img.h, box_w, box_h).ok_or(PdfError::Write("letterbox".into()))?;
    let x = rect.x.as_f64_pt() + dx as f64;
    let y_top = rect.y.as_f64_pt() + dy as f64;
    let pdf_x = x as f32;
    let pdf_y = pdf_y(page.page_h, y_top + dh as f64);
    let name = Name(img.name.as_bytes());
    page.content.save_state();
    page.content
        .transform([dw as f32, 0.0, 0.0, dh as f32, pdf_x, pdf_y]);
    page.content.x_object(name);
    page.content.restore_state();
    Ok(())
}

pub fn collect_image_srcs(lock: &k2f_core::LockFile) -> Vec<String> {
    let mut srcs = Vec::new();
    for page in &lock.render_plan.pages {
        for op in &page.ops {
            if let k2f_core::PaintOp::DrawImage { src, .. } = op {
                if !srcs.contains(src) {
                    srcs.push(src.clone());
                }
            }
        }
    }
    srcs
}