PDF와 Office 문서 양방향 변환

Microsoft Office 문서(Word, Excel, PowerPoint)를 PDF로 변환하거나, PDF를 다시 DOCX, PPTX, XLSX로 변환할 수 있습니다 — Microsoft Office나 LibreOffice 설치 없이. PDF Oxide는 OOXML 형식을 직접 파싱하여 PDF를 생성하고, PDF 페이지를 편집 가능한 Office 문서로 렌더링합니다.

변환은 두 방향을 지원합니다.

• Office → PDF — OfficeConverter 클래스(및 open_from_*_bytes 생성자)가 DOCX/XLSX/PPTX를 파싱하여 PDF를 생성합니다.
• PDF → Office — 열린 문서의 to_docx / to_pptx / to_xlsx 메서드로 Office 형식으로 내보냅니다.

빠른 예제

Python

from pdf_oxide import OfficeConverter

# Auto-detect format from extension
pdf = OfficeConverter.convert("report.docx")
pdf.save("report.pdf")

Rust

use pdf_oxide::converters::office::OfficeConverter;

let converter = OfficeConverter::new();
let pdf_bytes = converter.convert("report.docx")?;
std::fs::write("report.pdf", pdf_bytes)?;

C++

#include <pdf_oxide/pdf_oxide.hpp>
#include <fstream>

std::ifstream in("report.docx", std::ios::binary);
std::vector<std::uint8_t> docx((std::istreambuf_iterator<char>(in)), {});

auto doc = pdf_oxide::Document::open_from_docx_bytes(docx);
auto pdf = doc.get_source_bytes();
std::ofstream("report.pdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(pdf.data()), pdf.size());

Dart

import 'dart:io';
import 'package:pdf_oxide/pdf_oxide.dart';

final docx = File('report.docx').readAsBytesSync();
final doc = PdfDocument.openFromDocxBytes(docx);
File('report.pdf').writeAsBytesSync(doc.getSourceBytes());

R

library(pdfoxide)

docx <- readBin("report.docx", "raw", file.info("report.docx")$size)
doc  <- pdf_open_from_docx_bytes(docx)
writeBin(pdf_get_source_bytes(doc), "report.pdf")

Julia

using PdfOxide

docx = read("report.docx")
doc  = open_from_docx_bytes(docx)
write("report.pdf", get_source_bytes(doc))

Zig

const pdf_oxide = @import("pdf_oxide");
const a = std.heap.page_allocator;

const docx = try std.fs.cwd().readFileAlloc("report.docx", a, .unlimited);
var doc = try pdf_oxide.Document.openFromDocxBytes(docx);
const pdf = try doc.sourceBytes(a);
try std.fs.cwd().writeFile(.{ .sub_path = "report.pdf", .data = pdf });

Objective-C

#import "POXPdfOxide.h"
NSError *err = nil;

NSData *docx = [NSData dataWithContentsOfFile:@"report.docx"];
POXDocument *doc = [POXDocument openFromDocxBytes:docx error:&err];
NSData *pdf = [doc sourceBytesWithError:&err];
[pdf writeToFile:@"report.pdf" atomically:YES];

Elixir

docx = File.read!("report.docx")
{:ok, doc} = PdfOxide.open_from_docx_bytes(docx)
{:ok, pdf} = PdfOxide.source_bytes(doc)
File.write!("report.pdf", pdf)

---

지원 형식

형식	확장자	설명
DOCX	.docx	Word 문서 — 단락, 제목, 목록, 텍스트 서식
XLSX	.xlsx, .xls	Excel 스프레드시트 — 다중 시트, 자동 열 너비, 셀 타입
PPTX	.pptx	PowerPoint 프레젠테이션 — 슬라이드, 제목, 텍스트 상자

---

Word 문서 (DOCX)

제목, 단락, 목록, 텍스트 서식(굵게, 기울임, 밑줄, 색상, 글꼴 크기)을 유지하며 Word 문서를 변환합니다.

Python

from pdf_oxide import OfficeConverter

pdf = OfficeConverter.from_docx("document.docx")
pdf.save("document.pdf")

Rust

use pdf_oxide::converters::office::OfficeConverter;

let converter = OfficeConverter::new();
let pdf_bytes = converter.convert_docx("document.docx")?;
std::fs::write("document.pdf", pdf_bytes)?;

C++

#include <pdf_oxide/pdf_oxide.hpp>
#include <fstream>

std::ifstream in("document.docx", std::ios::binary);
std::vector<std::uint8_t> docx((std::istreambuf_iterator<char>(in)), {});

auto doc = pdf_oxide::Document::open_from_docx_bytes(docx);
auto pdf = doc.get_source_bytes();
std::ofstream("document.pdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(pdf.data()), pdf.size());

Dart

import 'dart:io';
import 'package:pdf_oxide/pdf_oxide.dart';

final docx = File('document.docx').readAsBytesSync();
final doc = PdfDocument.openFromDocxBytes(docx);
File('document.pdf').writeAsBytesSync(doc.getSourceBytes());

R

library(pdfoxide)

docx <- readBin("document.docx", "raw", file.info("document.docx")$size)
doc  <- pdf_open_from_docx_bytes(docx)
writeBin(pdf_get_source_bytes(doc), "document.pdf")

Julia

using PdfOxide

docx = read("document.docx")
doc  = open_from_docx_bytes(docx)
write("document.pdf", get_source_bytes(doc))

Zig

const pdf_oxide = @import("pdf_oxide");
const a = std.heap.page_allocator;

const docx = try std.fs.cwd().readFileAlloc("document.docx", a, .unlimited);
var doc = try pdf_oxide.Document.openFromDocxBytes(docx);
const pdf = try doc.sourceBytes(a);
try std.fs.cwd().writeFile(.{ .sub_path = "document.pdf", .data = pdf });

Objective-C

#import "POXPdfOxide.h"
NSError *err = nil;

NSData *docx = [NSData dataWithContentsOfFile:@"document.docx"];
POXDocument *doc = [POXDocument openFromDocxBytes:docx error:&err];
NSData *pdf = [doc sourceBytesWithError:&err];
[pdf writeToFile:@"document.pdf" atomically:YES];

Elixir

docx = File.read!("document.docx")
{:ok, doc} = PdfOxide.open_from_docx_bytes(docx)
{:ok, pdf} = PdfOxide.source_bytes(doc)
File.write!("document.pdf", pdf)

바이트에서 변환

Python

from pdf_oxide import OfficeConverter

with open("document.docx", "rb") as f:
    pdf = OfficeConverter.from_docx_bytes(f.read())
pdf.save("document.pdf")

Rust

let docx_bytes = std::fs::read("document.docx")?;
let converter = OfficeConverter::new();
let pdf_bytes = converter.convert_docx_bytes(&docx_bytes)?;
std::fs::write("document.pdf", pdf_bytes)?;

C++

std::ifstream in("document.docx", std::ios::binary);
std::vector<std::uint8_t> docx_bytes((std::istreambuf_iterator<char>(in)), {});

auto doc = pdf_oxide::Document::open_from_docx_bytes(docx_bytes);
auto pdf_bytes = doc.get_source_bytes();
std::ofstream("document.pdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(pdf_bytes.data()), pdf_bytes.size());

Dart

final docxBytes = File('document.docx').readAsBytesSync();
final doc = PdfDocument.openFromDocxBytes(docxBytes);
File('document.pdf').writeAsBytesSync(doc.getSourceBytes());

R

docx_bytes <- readBin("document.docx", "raw", file.info("document.docx")$size)
doc <- pdf_open_from_docx_bytes(docx_bytes)
writeBin(pdf_get_source_bytes(doc), "document.pdf")

Julia

docx_bytes = read("document.docx")
doc = open_from_docx_bytes(docx_bytes)
write("document.pdf", get_source_bytes(doc))

Zig

const docx_bytes = try std.fs.cwd().readFileAlloc("document.docx", a, .unlimited);
var doc = try pdf_oxide.Document.openFromDocxBytes(docx_bytes);
const pdf_bytes = try doc.sourceBytes(a);
try std.fs.cwd().writeFile(.{ .sub_path = "document.pdf", .data = pdf_bytes });

Objective-C

NSData *docxBytes = [NSData dataWithContentsOfFile:@"document.docx"];
POXDocument *doc = [POXDocument openFromDocxBytes:docxBytes error:&err];
NSData *pdfBytes = [doc sourceBytesWithError:&err];
[pdfBytes writeToFile:@"document.pdf" atomically:YES];

Elixir

docx_bytes = File.read!("document.docx")
{:ok, doc} = PdfOxide.open_from_docx_bytes(docx_bytes)
{:ok, pdf_bytes} = PdfOxide.source_bytes(doc)
File.write!("document.pdf", pdf_bytes)

지원되는 DOCX 기능

• 정렬이 있는 단락 (왼쪽, 가운데, 오른쪽, 양쪽)
• 제목 (제목 1–9 스타일)
• 텍스트 서식: 굵게, 기울임, 밑줄, 취소선
• 글꼴 크기 및 색상
• 번호 매기기 및 글머리 기호 목록 (중첩 지원)
• 메타데이터 추출 (docProps/core.xml에서 제목, 작성자)

---

Excel 스프레드시트 (XLSX)

자동 열 너비 계산과 다중 시트 지원으로 스프레드시트를 PDF로 변환합니다. 각 시트는 별도 섹션으로 렌더링됩니다.

Python

from pdf_oxide import OfficeConverter

pdf = OfficeConverter.from_xlsx("data.xlsx")
pdf.save("data.pdf")

Rust

let converter = OfficeConverter::new();
let pdf_bytes = converter.convert_xlsx("data.xlsx")?;
std::fs::write("data.pdf", pdf_bytes)?;

C++

std::ifstream in("data.xlsx", std::ios::binary);
std::vector<std::uint8_t> xlsx((std::istreambuf_iterator<char>(in)), {});

auto doc = pdf_oxide::Document::open_from_xlsx_bytes(xlsx);
auto pdf = doc.get_source_bytes();
std::ofstream("data.pdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(pdf.data()), pdf.size());

Dart

final xlsx = File('data.xlsx').readAsBytesSync();
final doc = PdfDocument.openFromXlsxBytes(xlsx);
File('data.pdf').writeAsBytesSync(doc.getSourceBytes());

R

xlsx <- readBin("data.xlsx", "raw", file.info("data.xlsx")$size)
doc  <- pdf_open_from_xlsx_bytes(xlsx)
writeBin(pdf_get_source_bytes(doc), "data.pdf")

Julia

xlsx = read("data.xlsx")
doc  = open_from_xlsx_bytes(xlsx)
write("data.pdf", get_source_bytes(doc))

Zig

const xlsx = try std.fs.cwd().readFileAlloc("data.xlsx", a, .unlimited);
var doc = try pdf_oxide.Document.openFromXlsxBytes(xlsx);
const pdf = try doc.sourceBytes(a);
try std.fs.cwd().writeFile(.{ .sub_path = "data.pdf", .data = pdf });

Objective-C

NSData *xlsx = [NSData dataWithContentsOfFile:@"data.xlsx"];
POXDocument *doc = [POXDocument openFromXlsxBytes:xlsx error:&err];
NSData *pdf = [doc sourceBytesWithError:&err];
[pdf writeToFile:@"data.pdf" atomically:YES];

Elixir

xlsx = File.read!("data.xlsx")
{:ok, doc} = PdfOxide.open_from_xlsx_bytes(xlsx)
{:ok, pdf} = PdfOxide.source_bytes(doc)
File.write!("data.pdf", pdf)

지원되는 XLSX 기능

• 시트 제목이 있는 다중 시트 렌더링
• 셀 타입: 문자열, 정수, 부동소수점, 불리언, 날짜, 오류
• 자동 열 너비 계산
• 내용이 사용 가능한 공간을 초과할 때 자동 페이지 나누기

---

PowerPoint 프레젠테이션 (PPTX)

프레젠테이션을 PDF로 변환합니다. 각 슬라이드는 제목과 텍스트 상자가 추출되어 한 페이지가 됩니다.

Python

from pdf_oxide import OfficeConverter

pdf = OfficeConverter.from_pptx("slides.pptx")
pdf.save("slides.pdf")

Rust

let converter = OfficeConverter::new();
let pdf_bytes = converter.convert_pptx("slides.pptx")?;
std::fs::write("slides.pdf", pdf_bytes)?;

C++

std::ifstream in("slides.pptx", std::ios::binary);
std::vector<std::uint8_t> pptx((std::istreambuf_iterator<char>(in)), {});

auto doc = pdf_oxide::Document::open_from_pptx_bytes(pptx);
auto pdf = doc.get_source_bytes();
std::ofstream("slides.pdf", std::ios::binary)
    .write(reinterpret_cast<const char*>(pdf.data()), pdf.size());

Dart

final pptx = File('slides.pptx').readAsBytesSync();
final doc = PdfDocument.openFromPptxBytes(pptx);
File('slides.pdf').writeAsBytesSync(doc.getSourceBytes());

R

pptx <- readBin("slides.pptx", "raw", file.info("slides.pptx")$size)
doc  <- pdf_open_from_pptx_bytes(pptx)
writeBin(pdf_get_source_bytes(doc), "slides.pdf")

Julia

pptx = read("slides.pptx")
doc  = open_from_pptx_bytes(pptx)
write("slides.pdf", get_source_bytes(doc))

Zig

const pptx = try std.fs.cwd().readFileAlloc("slides.pptx", a, .unlimited);
var doc = try pdf_oxide.Document.openFromPptxBytes(pptx);
const pdf = try doc.sourceBytes(a);
try std.fs.cwd().writeFile(.{ .sub_path = "slides.pdf", .data = pdf });

Objective-C

NSData *pptx = [NSData dataWithContentsOfFile:@"slides.pptx"];
POXDocument *doc = [POXDocument openFromPptxBytes:pptx error:&err];
NSData *pdf = [doc sourceBytesWithError:&err];
[pdf writeToFile:@"slides.pdf" atomically:YES];

Elixir

pptx = File.read!("slides.pptx")
{:ok, doc} = PdfOxide.open_from_pptx_bytes(pptx)
{:ok, pdf} = PdfOxide.source_bytes(doc)
File.write!("slides.pdf", pdf)

---

PDF를 DOCX, PPTX, XLSX로 변환하는 방법

역방향 변환(PDF → Office)은 OfficeConverter가 아닌 열린 PDF 문서의 메서드로 수행합니다. PdfDocument(Python/Rust), OpenFromBytes/Open(Go/C#), 또는 Document.open(Swift)으로 PDF를 열고 to_docx / to_pptx / to_xlsx를 호출하여 Office 형식으로 내보냅니다.

PDF Oxide는 페이지 수에 따라 내보내기 전략을 자동으로 선택합니다. 레이아웃 임계값(DOCX/PPTX는 30페이지, XLSX는 200페이지) 이하의 문서는 각 텍스트 스팬을 원본 위치에 가깝게 배치하는 레이아웃 보존 방식을 사용합니다. 더 큰 문서는 Word/PowerPoint/Excel에서 즉시 열 수 있도록 내용을 재배치하는 흐름 방식으로 전환됩니다. 각 PDF 페이지는 DOCX 섹션, PPTX 슬라이드, 또는 XLSX 워크시트가 되며, 원본 페이지 크기와 내장 글꼴이 보존되어 PDF → Office → PDF 왕복 변환 시 원래 레이아웃이 유지됩니다.

PDF를 Word(DOCX)로 변환

Rust

use pdf_oxide::document::PdfDocument;

let doc = PdfDocument::open("report.pdf")?;

// Write straight to disk
doc.to_docx("report.docx")?;

// Or get the bytes in memory
let docx_bytes: Vec<u8> = doc.to_docx_bytes()?;
std::fs::write("report.docx", docx_bytes)?;

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("report.pdf")

# Write straight to disk
doc.to_docx("report.docx")

# Or get the bytes in memory
docx_bytes = doc.to_docx_bytes()
with open("report.docx", "wb") as f:
    f.write(docx_bytes)

Go

doc, err := pdfoxide.Open("report.pdf")
if err != nil {
    log.Fatal(err)
}
defer doc.Close()

docxBytes, err := doc.ToDocxBytes()
if err != nil {
    log.Fatal(err)
}
os.WriteFile("report.docx", docxBytes, 0o644)

C#

using PdfOxide.Core;

using var doc = PdfDocument.Open("report.pdf");
byte[] docxBytes = doc.ToDocxBytes();
File.WriteAllBytes("report.docx", docxBytes);

Swift

import PdfOxide

let doc = try Document.open("report.pdf")
let docxBytes = try doc.toDocx()
try Data(docxBytes).write(to: URL(fileURLWithPath: "report.docx"))

C++

#include <pdf_oxide/pdf_oxide.hpp>
#include <fstream>

auto doc = pdf_oxide::Document::open("report.pdf");
auto docx_bytes = doc.to_docx();
std::ofstream("report.docx", std::ios::binary)
    .write(reinterpret_cast<const char*>(docx_bytes.data()), docx_bytes.size());

Dart

import 'dart:io';
import 'package:pdf_oxide/pdf_oxide.dart';

final doc = PdfDocument.open('report.pdf');
File('report.docx').writeAsBytesSync(doc.toDocx());

R

library(pdfoxide)

doc <- pdf_open("report.pdf")
writeBin(pdf_to_docx(doc), "report.docx")

Julia

using PdfOxide

doc = open_document("report.pdf")
write("report.docx", to_docx(doc))

Zig

const pdf_oxide = @import("pdf_oxide");
const a = std.heap.page_allocator;

var doc = try pdf_oxide.Document.open("report.pdf");
const docx_bytes = try doc.toDocx(a);
try std.fs.cwd().writeFile(.{ .sub_path = "report.docx", .data = docx_bytes });

Objective-C

#import "POXPdfOxide.h"
NSError *err = nil;

POXDocument *doc = [POXDocument openPath:@"report.pdf" error:&err];
NSData *docxBytes = [doc toDocxWithError:&err];
[docxBytes writeToFile:@"report.docx" atomically:YES];

Elixir

{:ok, doc} = PdfOxide.open("report.pdf")
{:ok, docx_bytes} = PdfOxide.to_docx(doc)
File.write!("report.docx", docx_bytes)

PDF를 PowerPoint(PPTX)로 변환

Rust

use pdf_oxide::document::PdfDocument;

let doc = PdfDocument::open("deck.pdf")?;
doc.to_pptx("deck.pptx")?;            // to disk
let pptx_bytes = doc.to_pptx_bytes()?; // or in memory

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("deck.pdf")
doc.to_pptx("deck.pptx")           # to disk
pptx_bytes = doc.to_pptx_bytes()   # or in memory

Go

doc, _ := pdfoxide.Open("deck.pdf")
defer doc.Close()
pptxBytes, err := doc.ToPptxBytes()
if err != nil {
    log.Fatal(err)
}
os.WriteFile("deck.pptx", pptxBytes, 0o644)

C#

using var doc = PdfDocument.Open("deck.pdf");
File.WriteAllBytes("deck.pptx", doc.ToPptxBytes());

Swift

let doc = try Document.open("deck.pdf")
let pptxBytes = try doc.toPptx()
try Data(pptxBytes).write(to: URL(fileURLWithPath: "deck.pptx"))

C++

auto doc = pdf_oxide::Document::open("deck.pdf");
auto pptx_bytes = doc.to_pptx();
std::ofstream("deck.pptx", std::ios::binary)
    .write(reinterpret_cast<const char*>(pptx_bytes.data()), pptx_bytes.size());

Dart

final doc = PdfDocument.open('deck.pdf');
File('deck.pptx').writeAsBytesSync(doc.toPptx());

R

doc <- pdf_open("deck.pdf")
writeBin(pdf_to_pptx(doc), "deck.pptx")

Julia

doc = open_document("deck.pdf")
write("deck.pptx", to_pptx(doc))

Zig

var doc = try pdf_oxide.Document.open("deck.pdf");
const pptx_bytes = try doc.toPptx(a);
try std.fs.cwd().writeFile(.{ .sub_path = "deck.pptx", .data = pptx_bytes });

Objective-C

POXDocument *doc = [POXDocument openPath:@"deck.pdf" error:&err];
NSData *pptxBytes = [doc toPptxWithError:&err];
[pptxBytes writeToFile:@"deck.pptx" atomically:YES];

Elixir

{:ok, doc} = PdfOxide.open("deck.pdf")
{:ok, pptx_bytes} = PdfOxide.to_pptx(doc)
File.write!("deck.pptx", pptx_bytes)

PDF를 Excel(XLSX)로 변환

Rust

use pdf_oxide::document::PdfDocument;

let doc = PdfDocument::open("table.pdf")?;
doc.to_xlsx("table.xlsx")?;            // to disk
let xlsx_bytes = doc.to_xlsx_bytes()?; // or in memory

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("table.pdf")
doc.to_xlsx("table.xlsx")          # to disk
xlsx_bytes = doc.to_xlsx_bytes()   # or in memory

Go

doc, _ := pdfoxide.Open("table.pdf")
defer doc.Close()
xlsxBytes, err := doc.ToXlsxBytes()
if err != nil {
    log.Fatal(err)
}
os.WriteFile("table.xlsx", xlsxBytes, 0o644)

C#

using var doc = PdfDocument.Open("table.pdf");
File.WriteAllBytes("table.xlsx", doc.ToXlsxBytes());

Swift

let doc = try Document.open("table.pdf")
let xlsxBytes = try doc.toXlsx()
try Data(xlsxBytes).write(to: URL(fileURLWithPath: "table.xlsx"))

C++

auto doc = pdf_oxide::Document::open("table.pdf");
auto xlsx_bytes = doc.to_xlsx();
std::ofstream("table.xlsx", std::ios::binary)
    .write(reinterpret_cast<const char*>(xlsx_bytes.data()), xlsx_bytes.size());

Dart

final doc = PdfDocument.open('table.pdf');
File('table.xlsx').writeAsBytesSync(doc.toXlsx());

R

doc <- pdf_open("table.pdf")
writeBin(pdf_to_xlsx(doc), "table.xlsx")

Julia

doc = open_document("table.pdf")
write("table.xlsx", to_xlsx(doc))

Zig

var doc = try pdf_oxide.Document.open("table.pdf");
const xlsx_bytes = try doc.toXlsx(a);
try std.fs.cwd().writeFile(.{ .sub_path = "table.xlsx", .data = xlsx_bytes });

Objective-C

POXDocument *doc = [POXDocument openPath:@"table.pdf" error:&err];
NSData *xlsxBytes = [doc toXlsxWithError:&err];
[xlsxBytes writeToFile:@"table.xlsx" atomically:YES];

Elixir

{:ok, doc} = PdfOxide.open("table.pdf")
{:ok, xlsx_bytes} = PdfOxide.to_xlsx(doc)
File.write!("table.xlsx", xlsx_bytes)

Python 참고: to_docx/to_pptx/to_xlsx는 Office → PDF 방향에 사용하는 OfficeConverter/Pdf 빌더가 아닌 PdfDocument(텍스트 추출/검사 클래스)에 정의되어 있습니다. 소스 PDF를 열 때는 PdfDocument("file.pdf")를 사용하세요.

---

Office 파일을 PDF 문서로 직접 여는 방법

네이티브 바인딩(Go, C#, Swift, C ABI)은 DOCX/PPTX/XLSX 바이트를 변환하여 이미 열린 PdfDocument를 반환하는 open_from_*_bytes 생성자를 제공합니다. 중간 PDF를 저장하지 않고 즉시 텍스트 추출, 렌더링, 재내보내기를 하려는 경우에 편리합니다. 각 생성자는 내부에서 OfficeConverter를 실행하고 결과 PDF를 한 번의 호출로 엽니다.

Go

data, err := os.ReadFile("contract.docx")
if err != nil {
    log.Fatal(err)
}

doc, err := pdfoxide.OpenFromDocxBytes(data)
if err != nil {
    log.Fatal(err)
}
defer doc.Close()

// Now work with it as a normal PDF document
text, _ := doc.ExtractText(0)
fmt.Println(text)

C#

using PdfOxide.Core;

byte[] data = File.ReadAllBytes("contract.docx");
using var doc = PdfDocument.OpenFromDocxBytes(data);

// Use it like any other open PDF — extract, render, or re-export
byte[] pdfBytes = doc.ToDocxBytes(); // round-trip if you like

Swift

import PdfOxide
import Foundation

let data = try Data(contentsOf: URL(fileURLWithPath: "contract.docx"))
let doc = try Document.openFromDocxBytes([UInt8](data))
let pageCount = try doc.pageCount()
print("Converted DOCX has \(pageCount) page(s)")

C++

#include <pdf_oxide/pdf_oxide.hpp>
#include <fstream>

std::ifstream in("contract.docx", std::ios::binary);
std::vector<std::uint8_t> data((std::istreambuf_iterator<char>(in)), {});

auto doc = pdf_oxide::Document::open_from_docx_bytes(data);
// Now work with it as a normal PDF document
auto text = doc.extract_text(0);

Dart

import 'dart:io';
import 'package:pdf_oxide/pdf_oxide.dart';

final data = File('contract.docx').readAsBytesSync();
final doc = PdfDocument.openFromDocxBytes(data);
final text = doc.extractText(0);

R

library(pdfoxide)

data <- readBin("contract.docx", "raw", file.info("contract.docx")$size)
doc  <- pdf_open_from_docx_bytes(data)
text <- pdf_extract_text(doc, 0)

Julia

using PdfOxide

data = read("contract.docx")
doc  = open_from_docx_bytes(data)
text = extract_text(doc, 0)

Zig

const pdf_oxide = @import("pdf_oxide");
const a = std.heap.page_allocator;

const data = try std.fs.cwd().readFileAlloc("contract.docx", a, .unlimited);
var doc = try pdf_oxide.Document.openFromDocxBytes(data);
const text = try doc.extractText(a, 0);

Objective-C

#import "POXPdfOxide.h"
NSError *err = nil;

NSData *data = [NSData dataWithContentsOfFile:@"contract.docx"];
POXDocument *doc = [POXDocument openFromDocxBytes:data error:&err];
NSString *text = [doc extractText:0 error:&err];

Elixir

data = File.read!("contract.docx")
{:ok, doc} = PdfOxide.open_from_docx_bytes(data)
{:ok, text} = PdfOxide.extract_text(doc, 0)

PPTX와 XLSX는 해당 생성자를 사용합니다.

소스 형식	Go	C#	Swift
DOCX	OpenFromDocxBytes(data)	PdfDocument.OpenFromDocxBytes(data)	Document.openFromDocxBytes(bytes)
PPTX	OpenFromPptxBytes(data)	PdfDocument.OpenFromPptxBytes(data)	Document.openFromPptxBytes(bytes)
XLSX	OpenFromXlsxBytes(data)	PdfDocument.OpenFromXlsxBytes(data)	Document.openFromXlsxBytes(bytes)

Rust / Python: 코어 PdfDocument에는 open_from_docx_bytes 생성자가 없습니다. Rust에서는 먼저 OfficeConverter::new().convert_docx_bytes(&data)?로 변환한 후 PdfDocument::from_bytes(pdf_bytes)?를 호출하세요. Python에서는 위에 설명된 OfficeConverter.from_docx_bytes(data)를 사용하면 Pdf가 반환됩니다.

use pdf_oxide::converters::office::OfficeConverter;
use pdf_oxide::document::PdfDocument;

let data = std::fs::read("contract.docx")?;
let pdf_bytes = OfficeConverter::new().convert_docx_bytes(&data)?;
let doc = PdfDocument::from_bytes(pdf_bytes)?;
println!("{} pages", doc.page_count()?);

---

설정 (Rust)

OfficeConfig를 사용하여 페이지 크기, 여백, 글꼴을 커스터마이징할 수 있습니다.

use pdf_oxide::converters::office::{OfficeConverter, OfficeConfig};

let config = OfficeConfig::a4(); // A4 page size
let converter = OfficeConverter::with_config(config);
let pdf_bytes = converter.convert_docx("document.docx")?;

OfficeConfig 필드

필드	타입	기본값	설명
page_size	PageSize	Letter	페이지 크기
margins	Margins	전체 1인치	포인트 단위 페이지 여백 (72pt = 1인치)
embed_fonts	bool	false	글꼴 포함 여부
default_font	String	"Helvetica"	대체 글꼴
default_font_size	f32	11.0	기본 텍스트 크기 (포인트)
line_height	f32	1.2	줄 높이 배수
include_images	bool	true	내장 이미지 포함 여부

페이지 크기 프리셋

let config = OfficeConfig::letter(); // 8.5 × 11 inches (default)
let config = OfficeConfig::a4();     // 210 × 297 mm

사용자 정의 여백

use pdf_oxide::converters::office::Margins;

let mut config = OfficeConfig::letter();
config.margins = Margins::uniform(36.0);  // 0.5 inch margins
config.margins = Margins::none();          // No margins

---

일괄 변환

Python

from pdf_oxide import OfficeConverter
from pathlib import Path

office_dir = Path("documents/")
output_dir = Path("pdfs/")
output_dir.mkdir(exist_ok=True)

extensions = {".docx", ".xlsx", ".pptx"}

for doc_path in office_dir.iterdir():
    if doc_path.suffix.lower() in extensions:
        pdf = OfficeConverter.convert(str(doc_path))
        pdf.save(str(output_dir / doc_path.with_suffix(".pdf").name))
        print(f"Converted: {doc_path.name}")

Rust

use pdf_oxide::converters::office::OfficeConverter;
use std::fs;

let converter = OfficeConverter::new();

for entry in fs::read_dir("documents/")? {
    let path = entry?.path();
    match path.extension().and_then(|e| e.to_str()) {
        Some("docx" | "xlsx" | "pptx") => {
            let pdf_bytes = converter.convert(&path)?;
            let out = format!("pdfs/{}.pdf", path.file_stem().unwrap().to_str().unwrap());
            fs::write(&out, pdf_bytes)?;
            println!("Converted: {}", path.display());
        }
        _ => {}
    }
}

C++

#include <pdf_oxide/pdf_oxide.hpp>
#include <filesystem>
#include <fstream>
namespace fs = std::filesystem;

for (const auto& entry : fs::directory_iterator("documents/")) {
    auto path = entry.path();
    auto ext = path.extension().string();

    if (ext != ".docx" && ext != ".xlsx" && ext != ".pptx") continue;

    std::ifstream in(path, std::ios::binary);
    std::vector<std::uint8_t> bytes((std::istreambuf_iterator<char>(in)), {});

    auto doc =
        ext == ".docx" ? pdf_oxide::Document::open_from_docx_bytes(bytes)
        : ext == ".xlsx" ? pdf_oxide::Document::open_from_xlsx_bytes(bytes)
                         : pdf_oxide::Document::open_from_pptx_bytes(bytes);

    auto pdf = doc.get_source_bytes();
    auto out = "pdfs/" + path.stem().string() + ".pdf";
    std::ofstream(out, std::ios::binary)
        .write(reinterpret_cast<const char*>(pdf.data()), pdf.size());
}

Dart

import 'dart:io';
import 'package:pdf_oxide/pdf_oxide.dart';

Directory('pdfs').createSync(recursive: true);

for (final entry in Directory('documents').listSync()) {
  if (entry is! File) continue;
  final ext = entry.path.split('.').last.toLowerCase();
  final bytes = entry.readAsBytesSync();

  final doc = switch (ext) {
    'docx' => PdfDocument.openFromDocxBytes(bytes),
    'xlsx' => PdfDocument.openFromXlsxBytes(bytes),
    'pptx' => PdfDocument.openFromPptxBytes(bytes),
    _ => null,
  };
  if (doc == null) continue;

  final name = entry.uri.pathSegments.last.replaceAll(RegExp(r'\.\w+$'), '');
  File('pdfs/$name.pdf').writeAsBytesSync(doc.getSourceBytes());
}

R

library(pdfoxide)

dir.create("pdfs", showWarnings = FALSE)

for (path in list.files("documents", full.names = TRUE)) {
  ext   <- tolower(tools::file_ext(path))
  bytes <- readBin(path, "raw", file.info(path)$size)

  doc <- switch(ext,
    docx = pdf_open_from_docx_bytes(bytes),
    xlsx = pdf_open_from_xlsx_bytes(bytes),
    pptx = pdf_open_from_pptx_bytes(bytes),
    next)

  out <- file.path("pdfs", paste0(tools::file_path_sans_ext(basename(path)), ".pdf"))
  writeBin(pdf_get_source_bytes(doc), out)
}

Julia

using PdfOxide

mkpath("pdfs")

for path in readdir("documents"; join = true)
    ext   = lowercase(splitext(path)[2])
    bytes = read(path)

    doc = if ext == ".docx"
        open_from_docx_bytes(bytes)
    elseif ext == ".xlsx"
        open_from_xlsx_bytes(bytes)
    elseif ext == ".pptx"
        open_from_pptx_bytes(bytes)
    else
        continue
    end

    name = first(splitext(basename(path)))
    write(joinpath("pdfs", name * ".pdf"), get_source_bytes(doc))
end

Zig

const pdf_oxide = @import("pdf_oxide");
const a = std.heap.page_allocator;

try std.fs.cwd().makePath("pdfs");
var dir = try std.fs.cwd().openDir("documents", .{ .iterate = true });
var it = dir.iterate();
while (try it.next()) |entry| {
    const bytes = try dir.readFileAlloc(entry.name, a, .unlimited);

    var doc = if (std.mem.endsWith(u8, entry.name, ".docx"))
        try pdf_oxide.Document.openFromDocxBytes(bytes)
    else if (std.mem.endsWith(u8, entry.name, ".xlsx"))
        try pdf_oxide.Document.openFromXlsxBytes(bytes)
    else if (std.mem.endsWith(u8, entry.name, ".pptx"))
        try pdf_oxide.Document.openFromPptxBytes(bytes)
    else
        continue;

    const pdf = try doc.sourceBytes(a);
    const stem = entry.name[0 .. std.mem.lastIndexOfScalar(u8, entry.name, '.').?];
    const out = try std.fmt.allocPrint(a, "pdfs/{s}.pdf", .{stem});
    try std.fs.cwd().writeFile(.{ .sub_path = out, .data = pdf });
}

Objective-C

#import "POXPdfOxide.h"
NSError *err = nil;
NSFileManager *fm = [NSFileManager defaultManager];
[fm createDirectoryAtPath:@"pdfs" withIntermediateDirectories:YES attributes:nil error:&err];

for (NSString *name in [fm contentsOfDirectoryAtPath:@"documents" error:&err]) {
    NSString *path = [@"documents" stringByAppendingPathComponent:name];
    NSData *bytes = [NSData dataWithContentsOfFile:path];
    NSString *ext = name.pathExtension.lowercaseString;

    POXDocument *doc;
    if ([ext isEqualToString:@"docx"])      doc = [POXDocument openFromDocxBytes:bytes error:&err];
    else if ([ext isEqualToString:@"xlsx"]) doc = [POXDocument openFromXlsxBytes:bytes error:&err];
    else if ([ext isEqualToString:@"pptx"]) doc = [POXDocument openFromPptxBytes:bytes error:&err];
    else continue;

    NSData *pdf = [doc sourceBytesWithError:&err];
    NSString *out = [@"pdfs" stringByAppendingPathComponent:
        [name.stringByDeletingPathExtension stringByAppendingPathExtension:@"pdf"]];
    [pdf writeToFile:out atomically:YES];
}

Elixir

File.mkdir_p!("pdfs")

for name <- File.ls!("documents") do
  bytes = File.read!(Path.join("documents", name))

  result =
    case Path.extname(name) |> String.downcase() do
      ".docx" -> PdfOxide.open_from_docx_bytes(bytes)
      ".xlsx" -> PdfOxide.open_from_xlsx_bytes(bytes)
      ".pptx" -> PdfOxide.open_from_pptx_bytes(bytes)
      _ -> :skip
    end

  with {:ok, doc} <- result,
       {:ok, pdf} <- PdfOxide.source_bytes(doc) do
    out = Path.join("pdfs", Path.rootname(name) <> ".pdf")
    File.write!(out, pdf)
  end
end

---

API 참조

<a id=“office-pdf-officeconverter”></a>

Python — OfficeConverter

메서드	반환값	설명
OfficeConverter.convert(path)	Pdf	형식 자동 감지 후 변환
OfficeConverter.from_docx(path)	Pdf	DOCX 파일 변환
OfficeConverter.from_docx_bytes(data)	Pdf	바이트에서 DOCX 변환
OfficeConverter.from_xlsx(path)	Pdf	XLSX 파일 변환
OfficeConverter.from_xlsx_bytes(data)	Pdf	바이트에서 XLSX 변환
OfficeConverter.from_pptx(path)	Pdf	PPTX 파일 변환
OfficeConverter.from_pptx_bytes(data)	Pdf	바이트에서 PPTX 변환

모든 메서드는 Pdf 객체를 반환합니다. pdf.save("output.pdf") 또는 pdf.to_bytes()로 결과를 얻을 수 있습니다.

Rust — OfficeConverter

메서드	반환값	설명
OfficeConverter::new()	OfficeConverter	기본 설정으로 생성
OfficeConverter::with_config(config)	OfficeConverter	사용자 설정으로 생성
convert(path)	Result<Vec<u8>>	형식 자동 감지 후 변환
convert_docx(path)	Result<Vec<u8>>	DOCX 파일 변환
convert_docx_bytes(bytes)	Result<Vec<u8>>	바이트에서 DOCX 변환
convert_xlsx(path)	Result<Vec<u8>>	XLSX 파일 변환
convert_xlsx_bytes(bytes)	Result<Vec<u8>>	바이트에서 XLSX 변환
convert_pptx(path)	Result<Vec<u8>>	PPTX 파일 변환
convert_pptx_bytes(bytes)	Result<Vec<u8>>	바이트에서 PPTX 변환

PDF → Office — to_docx / to_pptx / to_xlsx

열린 PDF 문서에서 내보냅니다. Rust, Python, Go, C#, Swift에서 사용 가능.

언어	메서드	반환값	설명
Rust	PdfDocument::to_docx(path)	Result<()>	PDF를 디스크의 DOCX 파일로 내보내기
Rust	PdfDocument::to_docx_bytes()	Result<Vec<u8>>	PDF를 DOCX 바이트로 내보내기
Rust	PdfDocument::to_pptx(path) / to_pptx_bytes()	Result<()> / Result<Vec<u8>>	PDF를 PPTX로 내보내기
Rust	PdfDocument::to_xlsx(path) / to_xlsx_bytes()	Result<()> / Result<Vec<u8>>	PDF를 XLSX로 내보내기
Python	PdfDocument.to_docx(path) / to_docx_bytes()	None / bytes	PDF를 DOCX로 내보내기
Python	PdfDocument.to_pptx(path) / to_pptx_bytes()	None / bytes	PDF를 PPTX로 내보내기
Python	PdfDocument.to_xlsx(path) / to_xlsx_bytes()	None / bytes	PDF를 XLSX로 내보내기
Go	(*PdfDocument).ToDocxBytes()	([]byte, error)	PDF를 DOCX 바이트로 내보내기
Go	(*PdfDocument).ToPptxBytes()	([]byte, error)	PDF를 PPTX 바이트로 내보내기
Go	(*PdfDocument).ToXlsxBytes()	([]byte, error)	PDF를 XLSX 바이트로 내보내기
C#	PdfDocument.ToDocxBytes()	byte[]	PDF를 DOCX 바이트로 내보내기
C#	PdfDocument.ToPptxBytes()	byte[]	PDF를 PPTX 바이트로 내보내기
C#	PdfDocument.ToXlsxBytes()	byte[]	PDF를 XLSX 바이트로 내보내기
Swift	Document.toDocx()	[UInt8]	PDF를 DOCX 바이트로 내보내기
Swift	Document.toPptx()	[UInt8]	PDF를 PPTX 바이트로 내보내기
Swift	Document.toXlsx()	[UInt8]	PDF를 XLSX 바이트로 내보내기

Office → PDF 문서 — open_from_*_bytes

Office 바이트를 변환하여 열린 PDF 문서를 반환하는 네이티브 바인딩 편의 생성자. Go, C#, Swift, C ABI에서 사용 가능. Rust 코어 PdfDocument와 Python에서는 사용 불가 — 거기서는 OfficeConverter를 사용하세요(위 표 참조).

언어	생성자	반환값	설명
Go	OpenFromDocxBytes(data)	(*PdfDocument, error)	DOCX 바이트에서 PDF 문서 열기
Go	OpenFromPptxBytes(data)	(*PdfDocument, error)	PPTX 바이트에서 PDF 문서 열기
Go	OpenFromXlsxBytes(data)	(*PdfDocument, error)	XLSX 바이트에서 PDF 문서 열기
C#	PdfDocument.OpenFromDocxBytes(data)	PdfDocument	DOCX 바이트에서 PDF 문서 열기
C#	PdfDocument.OpenFromPptxBytes(data)	PdfDocument	PPTX 바이트에서 PDF 문서 열기
C#	PdfDocument.OpenFromXlsxBytes(data)	PdfDocument	XLSX 바이트에서 PDF 문서 열기
Swift	Document.openFromDocxBytes(bytes)	Document	DOCX 바이트에서 PDF 문서 열기
Swift	Document.openFromPptxBytes(bytes)	Document	PPTX 바이트에서 PDF 문서 열기
Swift	Document.openFromXlsxBytes(bytes)	Document	XLSX 바이트에서 PDF 문서 열기
C ABI	pdf_document_open_from_docx_bytes(data, len, error_code)	PdfDocument *	DOCX 바이트에서 PDF 문서 열기
C ABI	pdf_document_open_from_pptx_bytes(data, len, error_code)	PdfDocument *	PPTX 바이트에서 PDF 문서 열기
C ABI	pdf_document_open_from_xlsx_bytes(data, len, error_code)	PdfDocument *	XLSX 바이트에서 PDF 문서 열기

---

자주 묻는 질문

PDF를 DOCX로 변환하면 레이아웃이 유지되나요?

예, 한도 내에서 유지됩니다. 레이아웃 임계값(DOCX/PPTX는 30페이지, XLSX는 200페이지) 이하의 문서는 to_docx_bytes / to_pptx_bytes / to_xlsx_bytes가 각 PDF 텍스트 스팬을 위치가 지정된 편집 가능한 요소로 출력하고 원본 PDF의 글꼴을 내장하는 레이아웃 보존 방식을 사용합니다. 이 덕분에 PDF → Office → PDF 왕복 변환 시 원래 페이지 크기가 유지됩니다. 더 큰 문서는 Word/PowerPoint/Excel에서 즉시 열 수 있도록 텍스트를 실제 단락으로 재배치하는 흐름 방식으로 전환됩니다.

Word뿐만 아니라 PowerPoint나 Excel로도 변환할 수 있나요?

네. to_pptx/to_pptx_bytes는 각 PDF 페이지를 원본 MediaBox 크기에 맞춘 슬라이드 하나로 매핑하고, to_xlsx/to_xlsx_bytes는 각 페이지를 워크시트 하나로 매핑합니다. 둘 다 Rust, Python, Go, C#, Swift에서 사용할 수 있습니다.

Python에 open_from_docx_bytes 생성자가 없는 이유는 무엇인가요?

Python은 Office → PDF 방향을 더 높은 수준의 OfficeConverter 클래스를 통해 제공합니다(OfficeConverter.from_docx_bytes(data)가 Pdf를 반환). open_from_*_bytes 생성자는 별도의 변환기 클래스가 없는 네이티브 FFI 계층(Go, C#, Swift, C ABI)에 추가된 편의 래퍼입니다.

Microsoft Office나 LibreOffice를 설치해야 하나요?

아니요. PDF Oxide는 OOXML(DOCX/XLSX/PPTX) 형식을 순수 Rust로 직접 읽고 씁니다. 외부 프로세스 호출, COM 자동화, 헤드리스 Office 인스턴스가 전혀 없으며, Linux, macOS, Windows에서 동일하게 동작합니다.

---

관련 페이지

• Markdown에서 만들기 — Markdown 텍스트를 PDF로 변환
• HTML에서 만들기 — HTML을 PDF로 변환
• 이미지에서 만들기 — 이미지를 PDF로 변환
• 일괄 처리 — 병렬 처리 패턴