pdf-to-pptx

---
name: pdf-to-pptx
description: >-
  Convert a PDF into a PowerPoint (.pptx) by rasterizing every page to a
  high-resolution image and placing it full-bleed on a slide whose aspect ratio
  matches the page. This is the HIGH-FIDELITY / pixel-perfect path: the result
  looks exactly like the source PDF, but the text on each slide is NOT editable
  (each slide is an image). Use this whenever the user wants to turn a PDF into a
  PowerPoint / .pptx / slides, "put a PDF into PowerPoint", or convert a
  presentation PDF (e.g. a LaTeX/Beamer deck) to PowerPoint, AND they care more
  about looking identical to the original than about editing the text — even if
  they don't say "high fidelity". Especially apt for math-heavy or figure-heavy
  academic decks, where generic PDF→PPT converters mangle formulas and layout.
  Do NOT use this when the user needs the slide text/shapes to be EDITABLE in
  PowerPoint — that requires rebuilding the deck from scratch, not this
  image-based approach.
---

# PDF → PowerPoint (high-fidelity, page-as-image)

## What this does

Turns a PDF into a `.pptx` where **each page becomes one slide, rendered as a
crisp image that fills the slide edge-to-edge.** Visually indistinguishable from
the original PDF — formulas, figures, colors, fonts, and layout are all
preserved exactly, because nothing is re-typeset.

## When to use vs. when NOT to use

| Want… | Use this skill? |
|-------|-----------------|
| A PowerPoint that looks *exactly* like the PDF | ✅ Yes |
| To present a Beamer/LaTeX or other PDF deck in PowerPoint | ✅ Yes |
| Math/figure-heavy academic PDF (generic converters break these) | ✅ Yes |
| To **edit the text, bullets, or shapes** inside PowerPoint afterward | ❌ No — rebuild the deck instead (the text here is flat images) |

Generic online converters (Acrobat export, iLovePDF, Smallpdf, WPS) often
garble fonts/equations or just dump each page as a low-res image. This skill
gives a clean, reliable, high-resolution result with correct slide dimensions.

## Dependencies

- `python-pptx` and `Pillow` — `pip install python-pptx Pillow`
- A PDF renderer, **either**:
  - Poppler's `pdftoppm` on PATH (preferred — fastest, crispest), or
  - PyMuPDF — `pip install PyMuPDF` (the script falls back to this automatically)

## Quick start (one command)

The bundled script does everything (rasterize → assemble → save):

```bash
python scripts/pdf_to_pptx.py INPUT.pdf -o OUTPUT.pptx --dpi 300
```

- `-o/--output` is optional; defaults to the PDF's name with a `.pptx` extension.
- `--dpi`: `200` = fast/smaller, `300` = default (sharp, ~1080p-class), `400` = very crisp/larger.

That's usually all you need. The script preserves each page's aspect ratio (no
stretching), full-bleeds uniform decks, and letterboxes any odd-sized page on a
white background. Then run the **QA** step below.

## How it works (manual steps, if you're not using the script)

**1. Inspect the PDF** — confirm page count and page size/aspect:

```bash
pdfinfo INPUT.pdf | grep -iE "pages|page size"
# e.g. "Page size: 453.543 x 255.118 pts" -> 453.543/255.118 = 1.778 = 16:9
```

**2. Rasterize every page to a high-res PNG** (300 DPI):

```bash
mkdir -p pages
pdftoppm -png -r 300 INPUT.pdf pages/page   # -> pages/page-01.png, page-02.png, ...
```

**3. Assemble the PPTX** — match the slide aspect to the page so the image
fills it with **zero distortion**, then place each image full-bleed:

```python
import glob, re
from pptx import Presentation
from pptx.util import Emu
from PIL import Image

files = sorted(glob.glob("pages/*.png"),
               key=lambda p: int(re.findall(r"\d+", p)[-1]))
w_px, h_px = Image.open(files[0]).size          # e.g. 1890 x 1063
EMU = 914400
slide_h_in = 7.5
slide_w_in = slide_h_in * (w_px / h_px)         # derive width from page aspect
slide_w, slide_h = Emu(round(slide_w_in*EMU)), Emu(round(slide_h_in*EMU))

prs = Presentation()
prs.slide_width, prs.slide_height = slide_w, slide_h
blank = prs.slide_layouts[6]                     # fully blank layout
for f in files:
    s = prs.slides.add_slide(blank)
    s.shapes.add_picture(f, 0, 0, width=slide_w, height=slide_h)  # full-bleed
prs.save("OUTPUT.pptx")
```

**Key idea:** deriving `slide_w_in` from the rendered page's pixel aspect ratio
(rather than hard-coding 13.333×7.5) guarantees the image matches the slide
*exactly*, so it never gets squished. For mixed-size PDFs, use fit-and-center
instead of full-bleed (the bundled script does this for you).

**4. QA — render the result back to images and spot-check** (don't skip this):

```bash
# In this environment the pptx skill ships a LibreOffice helper:
python /mnt/skills/public/pptx/scripts/office/soffice.py --headless --convert-to pdf OUTPUT.pptx
# Otherwise: soffice --headless --convert-to pdf OUTPUT.pptx
pdftoppm -jpeg -r 110 OUTPUT.pdf check
```

Open `check-01.jpg`, a busy middle slide, and the last slide. Confirm:
- image fills the slide (no unexpected white borders or letterboxing),
- nothing is stretched/squished (text and circles look correct),
- all pages are present and in the right order,
- small text and equations are legible at the chosen DPI.

## Parameters & tuning

- **DPI** — controls sharpness and file size. 300 ≈ 1080p-class and is the
  default sweet spot. Go 400 for dense slides shown on 4K displays; drop to 200
  if file size matters more than crispness.
- **PNG vs JPEG** — keep PNG (lossless) for slides; it keeps text edges sharp and
  still compresses flat backgrounds well. JPEG can ring around text.
- **Non-16:9 or mixed-size PDFs** — the script picks the slide size from the
  first page and centers every other page (preserving its aspect, white bars if
  needed). A single `.pptx` can only have one slide size, so uniform decks are
  the clean case; mixed decks get tasteful letterboxing rather than distortion.
- **File size** — roughly (pages × DPI²). A 30-page deck at 300 DPI lands around
  5–8 MB, which is fine. If it balloons, lower the DPI.

## Caveat (state this to the user)

The text is **not editable** — every slide is a flat image, so you can't click in
and change words or numbers in PowerPoint. That's the deliberate trade-off for
pixel-perfect fidelity. If editable text/shapes are needed, this skill is the
wrong tool; rebuild the deck natively instead.