Struct Slide 

pub struct Slide {
    pub rel_path: String,
    pub slide_number: u32,
    pub elements: Vec<SlideElement>,
    pub images: Vec<ImageReference>,
    pub image_data: HashMap<String, Vec<u8>>,
    pub config: ParserConfig,
}

Represents a single slide extracted from a PowerPoint (pptx) file.

Contains structured slide data including slide number, parsed content elements (text, tables, images, lists), and associated image references.

A Slide can be converted into other formats, such as Markdown, or its contained images can be extracted in base64 representation.

Typically, you retrieve instances of Slide through [PptxContainer::parse()].

Fields

rel_path: String

slide_number: u32

elements: Vec<SlideElement>

images: Vec<ImageReference>

image_data: HashMap<String, Vec<u8>>

config: ParserConfig

Implementations

impl Slide

pub fn new( rel_path: String, slide_number: u32, elements: Vec<SlideElement>, images: Vec<ImageReference>, image_data: HashMap<String, Vec<u8>>, config: ParserConfig, ) -> Self

pub fn convert_to_md(&self) -> Option<String>

Converts slide contents into a Markdown formatted string.

Translates internal slide elements (text, tables, lists, images) to valid and readable Markdown. Embedded images will be encoded as base64 inline images.

Returns

Returns an Option<String>:

• Some(String): Markdown representation of slide if conversion succeeds.
• None: If a conversion error occurs during image encoding.

Examples found in repository

examples/save_images.rs (line 47)

fn main() -> Result<()> {
    // Get the PPTX file path from command line arguments and provide the mandatory output path
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example save_images <path/to/presentation.pptx>");
        return Ok(());
    };

    println!("Processing PPTX file: {}", pptx_path);

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(true)
        .compress_images(true)
        .quality(75)
        .image_handling_mode(ImageHandlingMode::Save)
        .image_output_path(PathBuf::from("C:/Users/nilsk/Downloads/extracted_images"))
        .build();

    // Open the PPTX file
    let mut container = PptxContainer::open(Path::new(pptx_path), config)?;

    // Parse all slides
    let slides = container.parse_all()?;

    println!("Found {} slides", slides.len());

    // create a new Markdown file
    let mut md_file = File::create("output.md")?;

    // Convert each slide to Markdown and save the images automatically
    for slide in slides {
        if let Some(md_content) = slide.convert_to_md() {
            writeln!(md_file, "{}", md_content).expect("Couldn't write to file");
        }
    }

    println!("All slides converted successfully!");

    Ok(())
}

examples/memory_efficient_streaming.rs (line 43)

fn main() -> Result<()> {
    // Get the PPTX file path from command line arguments
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example memory_efficient_streaming <path/to/presentation.pptx>");
        return Ok(());
    };

    println!("Processing PPTX file: {}", pptx_path);

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(true)
        .build();
    
    // Open the PPTX file with the streaming API
    let mut streamer = PptxContainer::open(Path::new(pptx_path), config)?;
    
    // Create output directory
    let output_dir = "output_streaming";
    fs::create_dir_all(output_dir)?;

    // Process slides one by one using the iterator
    for slide_result in streamer.iter_slides() {
        match slide_result {
            Ok(slide) => {
                println!("Processing slide {} ({} elements)", slide.slide_number, slide.elements.len());

                if let Some(md_content) = slide.convert_to_md() {
                    let output_path = format!("{}/slide_{}.md", output_dir, slide.slide_number);
                    fs::write(&output_path, md_content)?;
                    println!("Saved slide {} to {}", slide.slide_number, output_path);
                }
            },
            Err(e) => {
                eprintln!("Error processing slide: {:?}", e);
            }
        }
    }

    println!("All slides processed successfully!");

    Ok(())
}

examples/basic_usage.rs (line 54)

fn main() -> Result<()> {
    // Get the PPTX file path from command line arguments
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example basic_usage <path/to/presentation.pptx> <extract_images>\ncargo run --example basic_usage sample.pptx true");
        return Ok(());
    };
    
    // Tries to read if the extract_images flag is false else set to true
    let extract_images = if args.len() > 2 {
        !(args[2] == "false" || args[2] == "False" || args[2] == "0")
    } else {
        true
    };
    
    println!("Processing PPTX file: {}", pptx_path);

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(extract_images)
        .compress_images(true)
        .quality(75)
        .image_handling_mode(ImageHandlingMode::InMarkdown)
        .include_slide_comment(true)
        .build();
    
    // Open the PPTX file
    let mut container = PptxContainer::open(Path::new(pptx_path), config)?;

    // Parse all slides
    let slides = container.parse_all()?;

    println!("Found {} slides", slides.len());

    // create a new Markdown file
    let mut md_file = File::create("output.md")?;

    // Convert each slide to Markdown and save
    for slide in slides {
        if let Some(md_content) = slide.convert_to_md() {
            println!("{}", md_content);
            writeln!(md_file, "{}", md_content).expect("Couldn't write to file");
        }
    }

    println!("All slides converted successfully!");

    Ok(())
}

examples/manual_image_extraction.rs (line 55)

fn main() -> Result<()> {
    // Get the PPTX file path from command line arguments
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example manual_image_extraction <path/to/presentation.pptx>");
        return Ok(());
    };

    println!("Processing PPTX file: {}", pptx_path);

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(true)
        .compress_images(true)
        .quality(75)
        .image_handling_mode(ImageHandlingMode::Manually)
        .build();

    // Open the PPTX file
    let mut container = PptxContainer::open(Path::new(pptx_path), config)?;

    // Parse all slides
    let slides = container.parse_all()?;

    println!("Found {} slides", slides.len());

    // create a new Markdown file
    let mut md_file = File::create("output.md")?;

    // Create output directory
    let output_dir = "extracted_images";
    fs::create_dir_all(output_dir)?;

    // Process slides one by one using the iterator
    let mut image_count = 1;

    // Convert each slide to Markdown and save
    for slide in slides {
        if let Some(md_content) = slide.convert_to_md() {
            writeln!(md_file, "{}", md_content).expect("Couldn't write to file");
        }
        
        // Manually load the base64 encoded image strings from the slide
        if let Some(images) = slide.load_images_manually() {
            for image in images {
                
                // Decode the base64 strings back to raw image data
                let image_data = general_purpose::STANDARD.decode(image.base64_content.clone()).unwrap();

                // Extract image extension if the image is not compressed, otherwise its always `.jpg`
                let ext = slide.config.compress_images
                    .then(|| "jpg".to_string())
                    .unwrap_or_else(|| slide.get_image_extension(&image.img_ref.target.clone()));

                // Construct a unique file name
                let file_name = format!("slide{}_image{}_{}", slide.slide_number, image_count, &image.img_ref.id);
                
                // Save the image
                let output_path = format!(
                    "{}/{}.{}",
                    output_dir,
                    &file_name,
                    ext
                );
                fs::write(&output_path, image_data)?;
                println!("Saved image to {}", output_path);

                // Write the image data into the Markdown file
                writeln!(md_file, "![{}](data:image/{};base64,{})", file_name, ext, image.base64_content).expect("Couldn't write to file");
                
                image_count += 1;
            }
        }
    }

    println!("All slides converted successfully!");

    Ok(())
}

examples/performance_test.rs (line 116)

fn main() -> Result<()> {
    // Get the PPTX file path and optional iteration count from command line arguments
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example performance_test <path/to/presentation.pptx> [iterations]");
        return Ok(());
    };

    let iterations = if args.len() > 2 {
        args[2].parse().unwrap_or(5)
    } else {
        10 // Default to 10 iterations
    };

    println!("Performance testing with {} iterations on: {}", iterations, pptx_path);

    
    
    // =========== Single-threaded Approach ===========
    let mut single_thread_bench = Benchmark::new("Single-threaded parsing");

    let mut total_slides = 0;

    for i in 0..iterations {
        println!("\nIteration {} (Single-threaded)", i + 1);

        // Measure container creation
        let mut container = single_thread_bench.measure(|| {
            let config = ParserConfig::builder()
                .extract_images(true)
                .build();
            PptxContainer::open(Path::new(pptx_path), config).expect("Failed to open PPTX")
        });

        println!("  Found {} slides in the presentation", container.slide_count);

        // Measure parsing
        let slides = single_thread_bench.measure(|| {
            container.parse_all().expect("Failed to parse slides")
        });

        // Measure conversion
        let _md_content = single_thread_bench.measure(|| {
            slides.iter()
                .filter_map(|slide| slide.convert_to_md())
                .collect::<Vec<String>>()
        });

        total_slides += slides.len();
    }

    single_thread_bench.report();
    println!("Average slides per presentation: {}", total_slides / iterations);



    // =========== Single-threaded Streamed Approach ===========
    let mut single_thread_streamed_bench = Benchmark::new("Single-threaded streamed parsing");

    total_slides = 0;

    for i in 0..iterations {
        println!("\nIteration {} (Single-threaded streamed)", i + 1);

        // Measure container creation
        let mut container = single_thread_streamed_bench.measure(|| {
            let config = ParserConfig::builder()
                .extract_images(true)
                .build();
            PptxContainer::open(Path::new(pptx_path), config).expect("Failed to open PPTX")
        });

        println!("  Found {} slides in the presentation", container.slide_count);

        // Zähle die Slides im Voraus für die statistische Auswertung
        let expected_slides = container.slide_count;

        // Measure slide processing (including parsing and conversion)
        let slides_processed = single_thread_streamed_bench.measure(|| {
            let mut processed = 0;

            // Process slides one by one using the iterator
            for slide_result in container.iter_slides() {
                match slide_result {
                    Ok(slide) => {
                        // Konvertiere den Slide zu Markdown
                        let _md_content = slide.convert_to_md();
                        processed += 1;
                    },
                    Err(e) => {
                        eprintln!("Error processing slide: {:?}", e);
                    }
                }
            }

            processed
        });

        println!("  Processed {} out of {} slides", slides_processed, expected_slides);
        total_slides += slides_processed;
    }

    single_thread_streamed_bench.report();
    println!("Average slides per presentation: {}", total_slides / iterations);



    // =========== Optimized Multi-threaded Approach ===========
    let mut optimized_multi_thread_bench = Benchmark::new("Optimized Multi-threaded parsing");

    total_slides = 0;

    for i in 0..iterations {
        println!("\nIteration {} (Optimized Multi-threaded)", i + 1);

        // Container öffnen mit der gewünschten Konfiguration
        let mut container = optimized_multi_thread_bench.measure(|| {
            let config = ParserConfig::builder()
                .extract_images(true)
                .build();
            PptxContainer::open(Path::new(pptx_path), config).expect("Failed to open PPTX")
        });

        println!("  Found {} slides in the presentation", container.slide_count);

        // Verwende die neue optimierte Multi-Threading-Methode
        let slides = optimized_multi_thread_bench.measure(|| {
            container.parse_all_multi_threaded().expect("Failed to parse slides")
        });

        println!("  Successfully processed {} slides", slides.len());

        // Parallel zu Markdown konvertieren (bleibt unverändert)
        let _md_content = optimized_multi_thread_bench.measure(|| {
            slides.par_iter()
                .filter_map(|slide| slide.convert_to_md())
                .collect::<Vec<String>>()
        });

        total_slides += slides.len();
    }

    optimized_multi_thread_bench.report();
    println!("Average slides per presentation: {}", total_slides / iterations);

    // =========== Performance Comparison ===========
    if !single_thread_bench.results.is_empty() &&
        !single_thread_streamed_bench.results.is_empty() &&
        !optimized_multi_thread_bench.results.is_empty() {

        let single_avg: Duration = single_thread_bench.results.iter().sum::<Duration>() /
            single_thread_bench.results.len() as u32;
        let single_streamed_avg: Duration = single_thread_streamed_bench.results.iter().sum::<Duration>() /
            single_thread_streamed_bench.results.len() as u32;
        let optimized_multi_avg: Duration = optimized_multi_thread_bench.results.iter().sum::<Duration>() /
            optimized_multi_thread_bench.results.len() as u32;

        println!("\nPerformance Comparison");
        println!("=====================");
        println!("Single-threaded average: {:?}", single_avg);
        println!("Single-threaded streaming average: {:?}", single_streamed_avg);
        println!("Optimized multi-threaded average: {:?}", optimized_multi_avg);

        // Compare single-threaded vs single-threaded streaming
        if single_avg > single_streamed_avg {
            let speedup = single_avg.as_secs_f64() / single_streamed_avg.as_secs_f64();
            println!("Single-threaded streaming is {:.2}x faster than single-threaded", speedup);
        } else {
            let slowdown = single_streamed_avg.as_secs_f64() / single_avg.as_secs_f64();
            println!("Single-threaded streaming is {:.2}x slower than single-threaded", slowdown);
        }

        // Compare single-threaded vs optimized multithreaded
        if single_avg > optimized_multi_avg {
            let speedup = single_avg.as_secs_f64() / optimized_multi_avg.as_secs_f64();
            println!("Optimized multi-threaded is {:.2}x faster than single-threaded", speedup);
        } else {
            let slowdown = optimized_multi_avg.as_secs_f64() / single_avg.as_secs_f64();
            println!("Optimized multi-threaded is {:.2}x slower than single-threaded", slowdown);
        }

        // Compare single-threaded streaming vs optimized multithreaded
        if single_streamed_avg > optimized_multi_avg {
            let speedup = single_streamed_avg.as_secs_f64() / optimized_multi_avg.as_secs_f64();
            println!("Optimized multi-threaded is {:.2}x faster than single-threaded streaming", speedup);
        } else {
            let slowdown = optimized_multi_avg.as_secs_f64() / single_streamed_avg.as_secs_f64();
            println!("Optimized multi-threaded is {:.2}x slower than single-threaded streaming", slowdown);
        }

        // Determine the overall fastest approach
        let fastest_approach = if single_avg <= single_streamed_avg && single_avg <= optimized_multi_avg {
            "Single-threaded"
        } else if single_streamed_avg <= single_avg && single_streamed_avg <= optimized_multi_avg {
            "Single-threaded streaming"
        } else {
            "Optimized multi-threaded"
        };

        println!("\nOverall result: {} approach is the fastest for this workload.", fastest_approach);
    }

    Ok(())
}

pub fn extract_slide_number(path: &str) -> Option<u32>

Extracts the numeric slide identifier from a slide path.

Helper method to parse slide numbers from internal pptx slide paths (e.g., “ppt/slides/slide1.xml” → 1).

pub fn link_images(&mut self)

Links slide images references with their corresponding targets.

Ensures that each image referenced by its ID is correctly linked to the actual internal resource paths stored in the slide. This method is typically used internally after parsing a slide

Notes

Internally those are the values image references are holding

Parameter	Example value
id	rId2
target	../media/image2.png

pub fn get_image_extension(&self, path: &str) -> String

Extracts the file extension from image paths

Examples found in repository

examples/manual_image_extraction.rs (line 69)

fn main() -> Result<()> {
    // Get the PPTX file path from command line arguments
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example manual_image_extraction <path/to/presentation.pptx>");
        return Ok(());
    };

    println!("Processing PPTX file: {}", pptx_path);

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(true)
        .compress_images(true)
        .quality(75)
        .image_handling_mode(ImageHandlingMode::Manually)
        .build();

    // Open the PPTX file
    let mut container = PptxContainer::open(Path::new(pptx_path), config)?;

    // Parse all slides
    let slides = container.parse_all()?;

    println!("Found {} slides", slides.len());

    // create a new Markdown file
    let mut md_file = File::create("output.md")?;

    // Create output directory
    let output_dir = "extracted_images";
    fs::create_dir_all(output_dir)?;

    // Process slides one by one using the iterator
    let mut image_count = 1;

    // Convert each slide to Markdown and save
    for slide in slides {
        if let Some(md_content) = slide.convert_to_md() {
            writeln!(md_file, "{}", md_content).expect("Couldn't write to file");
        }
        
        // Manually load the base64 encoded image strings from the slide
        if let Some(images) = slide.load_images_manually() {
            for image in images {
                
                // Decode the base64 strings back to raw image data
                let image_data = general_purpose::STANDARD.decode(image.base64_content.clone()).unwrap();

                // Extract image extension if the image is not compressed, otherwise its always `.jpg`
                let ext = slide.config.compress_images
                    .then(|| "jpg".to_string())
                    .unwrap_or_else(|| slide.get_image_extension(&image.img_ref.target.clone()));

                // Construct a unique file name
                let file_name = format!("slide{}_image{}_{}", slide.slide_number, image_count, &image.img_ref.id);
                
                // Save the image
                let output_path = format!(
                    "{}/{}.{}",
                    output_dir,
                    &file_name,
                    ext
                );
                fs::write(&output_path, image_data)?;
                println!("Saved image to {}", output_path);

                // Write the image data into the Markdown file
                writeln!(md_file, "![{}](data:image/{};base64,{})", file_name, ext, image.base64_content).expect("Couldn't write to file");
                
                image_count += 1;
            }
        }
    }

    println!("All slides converted successfully!");

    Ok(())
}

pub fn compress_image(&self, image_data: &[u8]) -> Option<Vec<u8>>

Compresses the image data and returning it as a jpg byte slice

Parameter

• image_data: The raw image data as a byte array

Returns

• Vec<u8>: Returns the compressed and converted jpg byte array

Notes

All images will be converted to jpg

pub fn load_images_manually(&self) -> Option<Vec<ManualImage>>

Examples found in repository

examples/manual_image_extraction.rs (line 60)

fn main() -> Result<()> {
    // Get the PPTX file path from command line arguments
    let args: Vec<String> = env::args().collect();
    let pptx_path = if args.len() > 1 {
        &args[1]
    } else {
        eprintln!("Usage: cargo run --example manual_image_extraction <path/to/presentation.pptx>");
        return Ok(());
    };

    println!("Processing PPTX file: {}", pptx_path);

    // Use the config builder to build your config
    let config = ParserConfig::builder()
        .extract_images(true)
        .compress_images(true)
        .quality(75)
        .image_handling_mode(ImageHandlingMode::Manually)
        .build();

    // Open the PPTX file
    let mut container = PptxContainer::open(Path::new(pptx_path), config)?;

    // Parse all slides
    let slides = container.parse_all()?;

    println!("Found {} slides", slides.len());

    // create a new Markdown file
    let mut md_file = File::create("output.md")?;

    // Create output directory
    let output_dir = "extracted_images";
    fs::create_dir_all(output_dir)?;

    // Process slides one by one using the iterator
    let mut image_count = 1;

    // Convert each slide to Markdown and save
    for slide in slides {
        if let Some(md_content) = slide.convert_to_md() {
            writeln!(md_file, "{}", md_content).expect("Couldn't write to file");
        }
        
        // Manually load the base64 encoded image strings from the slide
        if let Some(images) = slide.load_images_manually() {
            for image in images {
                
                // Decode the base64 strings back to raw image data
                let image_data = general_purpose::STANDARD.decode(image.base64_content.clone()).unwrap();

                // Extract image extension if the image is not compressed, otherwise its always `.jpg`
                let ext = slide.config.compress_images
                    .then(|| "jpg".to_string())
                    .unwrap_or_else(|| slide.get_image_extension(&image.img_ref.target.clone()));

                // Construct a unique file name
                let file_name = format!("slide{}_image{}_{}", slide.slide_number, image_count, &image.img_ref.id);
                
                // Save the image
                let output_path = format!(
                    "{}/{}.{}",
                    output_dir,
                    &file_name,
                    ext
                );
                fs::write(&output_path, image_data)?;
                println!("Saved image to {}", output_path);

                // Write the image data into the Markdown file
                writeln!(md_file, "![{}](data:image/{};base64,{})", file_name, ext, image.base64_content).expect("Couldn't write to file");
                
                image_count += 1;
            }
        }
    }

    println!("All slides converted successfully!");

    Ok(())
}

Trait Implementations

impl Debug for Slide

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

Formats the value using the given formatter.