Struct ImageSource 

pub struct ImageSource {
    pub bytes: Vec<u8>,
    pub format: ImageFormat,
    pub page_size: PageSize,
}

Source for a single image page to be embedded in the OFD.

Each ImageSource becomes one page in the output document. The image fills the entire page boundary (no margins).

Fields

bytes: Vec<u8>

Raw image bytes.

format: ImageFormat

Detected or specified image format.

page_size: PageSize

Page size in millimeters.

Implementations

impl ImageSource

pub fn new( bytes: Vec<u8>, format: ImageFormat, width_mm: f64, height_mm: f64, ) -> Self

Create from image bytes with explicit format and mm dimensions.

pub fn jpeg(bytes: Vec<u8>, width_px: u32, height_px: u32, dpi: f64) -> Self

Create from JPEG bytes with known pixel dimensions and DPI.

pub fn jpeg_mm(bytes: Vec<u8>, width_mm: f64, height_mm: f64) -> Self

Create from JPEG bytes with page size in mm.

pub fn png_mm(bytes: Vec<u8>, width_mm: f64, height_mm: f64) -> Self

Create from PNG bytes with page size in mm.

pub fn auto_detect(bytes: Vec<u8>, dpi: f64) -> Option<Self>

Auto-detect format and dimensions, calculate page size from DPI.

Returns None if format or dimensions cannot be detected.

pub fn auto_detect_ppm(bytes: Vec<u8>, ppm: f64) -> Option<Self>

Auto-detect format and dimensions using pixels-per-mm ratio.

Uses ofdrw’s conversion: mm = pixels / ppm. See PPM_DEFAULT for the standard 5 px/mm ratio. Returns None if format or dimensions cannot be detected.

pub fn auto_detect_default(bytes: Vec<u8>) -> Option<Self>

Auto-detect format and dimensions using ofdrw’s default ratio (5 px/mm).

Equivalent to auto_detect_ppm(bytes, PPM_DEFAULT). Returns None if format or dimensions cannot be detected.

Examples found in repository

examples/image_to_ofd.rs (line 32)

fn main() {
    let args: Vec<String> = std::env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <input_image> [output.ofd]", args[0]);
        std::process::exit(1);
    }

    let input_path = &args[1];
    let output_path = if args.len() > 2 {
        args[2].clone()
    } else {
        let stem = Path::new(input_path)
            .file_stem()
            .and_then(|s| s.to_str())
            .unwrap_or("output");
        let parent = Path::new(input_path)
            .parent()
            .unwrap_or(Path::new("."));
        parent.join(format!("{}.ofd", stem)).to_string_lossy().into_owned()
    };

    let image_bytes = std::fs::read(input_path).expect("failed to read input file");

    // Auto-detect format + dimensions, use ofdrw default ratio (5 px/mm ≈ 127 DPI)
    let source = ImageSource::auto_detect_default(image_bytes)
        .expect("unsupported image format or cannot read dimensions");

    println!(
        "Image: {}x{} mm (page size)",
        format!("{:.1}", source.page_size.width_mm),
        format!("{:.1}", source.page_size.height_mm),
    );

    let ofd_bytes = OfdWriter::from_images(vec![source])
        .build()
        .expect("failed to build OFD");

    std::fs::write(&output_path, &ofd_bytes).expect("failed to write OFD file");
    println!("Created: {} ({} bytes)", output_path, ofd_bytes.len());
}

pub fn auto_detect_mm( bytes: Vec<u8>, width_mm: f64, height_mm: f64, ) -> Option<Self>

Auto-detect format, use explicit mm dimensions for page size.

Returns None if format cannot be detected from file header.