docuparse 0.0.1

Document extraction and parsing — PDF text, rendering, and OCR
Documentation
use image::DynamicImage;
use pdfium_render::prelude::{PdfPageIndex, PdfRenderConfig};

use crate::{
    error::{PdfError, RenderError},
    pdf_document::PdfDocument,
};

#[derive(Debug, Clone)]
pub struct RenderConfig {
    pub dpi: u32,
    pub with_annotations: bool,
    pub max_dimension_px: Option<i32>,
}

impl Default for RenderConfig {
    fn default() -> Self {
        Self {
            dpi: 150,
            with_annotations: false,
            max_dimension_px: Some(4096),
        }
    }
}

impl<'p> PdfDocument<'p> {
    pub fn render_page(
        &self,
        page_index: u32,
        config: &RenderConfig,
    ) -> Result<DynamicImage, PdfError> {
        let total = self.page_count();

        if page_index >= total {
            return Err(RenderError::PageOutOfRange {
                page: page_index,
                total,
            }
            .into());
        }

        let page = self
            .pages()
            .get(page_index as PdfPageIndex)
            .map_err(|_| RenderError::RenderFailed { page: page_index })?;

        // Derive render dimensions from actual page geometry.
        // PdfPoints are 1/72 inch — multiply
        // by dpi/72 to get the target pixel dimensions.
        let scale = config.dpi as f32 / 72.0;
        let mut width = (page.width().value * scale) as i32;
        let mut height = (page.height().value * scale) as i32;

        if let Some(max) = config.max_dimension_px {
            if width > max || height > max {
                let factor = max as f32 / width.max(height) as f32;
                width = (width as f32 * factor) as i32;
                height = (height as f32 * factor) as i32;
            }
        }

        let mut render_cfg = PdfRenderConfig::new()
            .set_target_width(width)
            .set_maximum_height(height);

        if config.with_annotations {
            render_cfg = render_cfg.render_annotations(true);
        }

        // NOTE: as_image() performs a full pixel-buffer copy out of pdfium's
        // internal bitmap. At high DPI this is a significant allocation.
        let image = page
            .render_with_config(&render_cfg)
            .map_err(|_| RenderError::RenderFailed { page: page_index })?
            .as_image()
            .map_err(|_| RenderError::BitmapConversionFailed { page: page_index })?;

        Ok(image)
    }

    /// Render all pages. Fails fast on the first page that cannot be rendered.
    pub fn render_all_pages(&self, config: &RenderConfig) -> Result<Vec<DynamicImage>, PdfError> {
        (0..self.page_count())
            .map(|i| self.render_page(i, config))
            .collect()
    }
}