Struct PdfiumBitmap

pub struct PdfiumBitmap { /* private fields */ }

Rust interface to FPDF_BITMAP

Implementations

impl PdfiumBitmap

pub fn empty( width: i32, height: i32, format: PdfiumBitmapFormat, ) -> PdfiumResult<Self>

Creates a new PdfiumBitmap with the given width, height and PdfiumBitmapFormat.

pub fn fill(&self, color: &PdfiumColor) -> PdfiumResult<()>

Fills this entire PdfiumBitmap with the given PdfiumColor.

pub fn width(&self) -> i32

Returns the width of the image in the bitmap buffer backing this PdfiumBitmap.

pub fn height(&self) -> i32

Returns the height of the image in the bitmap buffer backing this PdfiumBitmap.

Examples found in repository

examples/export_pages.rs (line 57)

pub fn example_export_pages_to_images() -> PdfiumResult<()> {
    // Load the PDF document from the specified file path
    // Parameters:
    // - "resources/groningen.pdf": Path to the PDF file (relative to current working directory)
    // - None: No password required for this PDF (use Some("password") if needed)
    let document = PdfiumDocument::new_from_path("resources/groningen.pdf", None)?;

    // Iterate through all pages in the document
    // document.pages() returns an iterator over all pages
    // enumerate() adds an index counter starting from 0
    // This gives us both the page object and its 0-based index
    for (index, page) in document.pages().enumerate() {
        // Render the current page as a bitmap image
        // This is where the PDF content gets converted to a raster image
        //
        // In the configuration we only specify the height in pixels. The width will be calculated
        // automatically to maintain aspect ratio.
        let config = PdfiumRenderConfig::new().with_height(1080);
        let bitmap = page?.render(&config)?;

        // Verify that the bitmap was rendered at the requested height
        // This assertion ensures the rendering process worked as expected
        // If this fails, it indicates a bug in the rendering logic
        assert_eq!(bitmap.height(), 1080);

        // Generate a unique filename for this page
        // Format: "groningen-page-{page_number}.jpg"
        // - index + 1 converts from 0-based index to 1-based page numbers
        //   * Page 0 becomes "groningen-page-1.jpg"
        //   * Page 1 becomes "groningen-page-2.jpg", etc.
        // - The .jpg extension indicates JPEG format will be used
        let filename = format!("groningen-page-{}.jpg", index + 1);

        // Save the rendered bitmap to disk as a JPEG image
        // Parameters:
        // - &filename: Reference to the generated filename string
        // - image::ImageFormat::Jpeg: Specifies JPEG compression format
        //   * Alternative format: Png (lossless)
        //   * JPEG provides good compression but is lossy (some quality loss)
        //
        // The save operation handles:
        // - Converting from BGRA format to JPEG-compatible format
        // - Applying JPEG compression
        // - Writing the file to disk
        bitmap.save(&filename, image::ImageFormat::Jpeg)?;

        // Note: No explicit cleanup needed - Rust's ownership system automatically
        // deallocates the bitmap memory when it goes out of scope at the end of this iteration
    }

    // Return success - all pages have been successfully exported
    Ok(())
}

pub fn format(&self) -> PdfiumBitmapFormat

Returns the pixel format of the image in the bitmap buffer backing this PdfiumBitmap.

pub fn as_raw_bytes<'a>(&self) -> &'a [u8]

Returns an immutable reference to the bitmap buffer backing this PdfiumBitmap.

This function does not attempt any color channel normalization.

pub fn as_rgba_bytes(&self) -> PdfiumResult<Vec<u8>>

Returns an owned copy of the bitmap buffer backing this PdfiumBitmap as RGBA.

Normalizing all color channels into RGBA irrespective of the original pixel format.

pub fn as_rgba8_image(&self) -> PdfiumResult<DynamicImage>

Returns a copy of this a bitmap as a DynamicImage::ImageRgba8

pub fn as_rgb8_image(&self) -> PdfiumResult<DynamicImage>

Returns a copy of this a bitmap as a DynamicImage::ImageRgb8

pub fn save(&self, path: &str, format: ImageFormat) -> PdfiumResult<()>

Saves this bitmap to the given path.

Include alpha channel only if the ImageFormat supports it.

Examples found in repository

examples/export_pages.rs (line 78)

pub fn example_export_pages_to_images() -> PdfiumResult<()> {
    // Load the PDF document from the specified file path
    // Parameters:
    // - "resources/groningen.pdf": Path to the PDF file (relative to current working directory)
    // - None: No password required for this PDF (use Some("password") if needed)
    let document = PdfiumDocument::new_from_path("resources/groningen.pdf", None)?;

    // Iterate through all pages in the document
    // document.pages() returns an iterator over all pages
    // enumerate() adds an index counter starting from 0
    // This gives us both the page object and its 0-based index
    for (index, page) in document.pages().enumerate() {
        // Render the current page as a bitmap image
        // This is where the PDF content gets converted to a raster image
        //
        // In the configuration we only specify the height in pixels. The width will be calculated
        // automatically to maintain aspect ratio.
        let config = PdfiumRenderConfig::new().with_height(1080);
        let bitmap = page?.render(&config)?;

        // Verify that the bitmap was rendered at the requested height
        // This assertion ensures the rendering process worked as expected
        // If this fails, it indicates a bug in the rendering logic
        assert_eq!(bitmap.height(), 1080);

        // Generate a unique filename for this page
        // Format: "groningen-page-{page_number}.jpg"
        // - index + 1 converts from 0-based index to 1-based page numbers
        //   * Page 0 becomes "groningen-page-1.jpg"
        //   * Page 1 becomes "groningen-page-2.jpg", etc.
        // - The .jpg extension indicates JPEG format will be used
        let filename = format!("groningen-page-{}.jpg", index + 1);

        // Save the rendered bitmap to disk as a JPEG image
        // Parameters:
        // - &filename: Reference to the generated filename string
        // - image::ImageFormat::Jpeg: Specifies JPEG compression format
        //   * Alternative format: Png (lossless)
        //   * JPEG provides good compression but is lossy (some quality loss)
        //
        // The save operation handles:
        // - Converting from BGRA format to JPEG-compatible format
        // - Applying JPEG compression
        // - Writing the file to disk
        bitmap.save(&filename, image::ImageFormat::Jpeg)?;

        // Note: No explicit cleanup needed - Rust's ownership system automatically
        // deallocates the bitmap memory when it goes out of scope at the end of this iteration
    }

    // Return success - all pages have been successfully exported
    Ok(())
}

Trait Implementations

impl Clone for PdfiumBitmap

fn clone(&self) -> PdfiumBitmap

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PdfiumBitmap

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&PdfiumBitmap> for FPDF_BITMAP

fn from(value: &PdfiumBitmap) -> Self

Converts to this type from the input type.