从图像创建

将图像转换为 PDF 文档。每张图像成为一页，在保持纵横比的同时调整尺寸以适应图像。支持 JPEG 和 PNG 格式。

快速示例

Python

from pdf_oxide import Pdf

# Single image
pdf = Pdf.from_image("photo.jpg")
pdf.save("photo.pdf")

# Multiple images
pdf = Pdf.from_images(["page1.jpg", "page2.png", "page3.jpg"])
pdf.save("album.pdf")

WASM

import { WasmPdf } from "pdf-oxide-wasm";
import { readFileSync, writeFileSync } from "fs";

// Single image from bytes
const imageData = new Uint8Array(readFileSync("photo.jpg"));
const pdf = WasmPdf.fromImageBytes(imageData);
writeFileSync("photo.pdf", pdf.toBytes());

// Multiple images
const images = ["page1.jpg", "page2.png", "page3.jpg"]
  .map(f => new Uint8Array(readFileSync(f)));
const album = WasmPdf.fromMultipleImageBytes(images);
writeFileSync("album.pdf", album.toBytes());

Rust

use pdf_oxide::api::Pdf;

// Single image
let pdf = Pdf::from_image("photo.jpg")?;
pdf.save("photo.pdf")?;

// Multiple images
let pdf = Pdf::from_images(&["page1.jpg", "page2.png", "page3.jpg"])?;
pdf.save("album.pdf")?;

Go

package main

import (
    "log"
    pdfoxide "github.com/yfedoseev/pdf_oxide/go"
)

func main() {
    // Single image
    pdf, err := pdfoxide.FromImage("photo.jpg")
    if err != nil { log.Fatal(err) }
    _ = pdf.Save("photo.pdf")
    pdf.Close()

    // From bytes (for in-memory images)
    data, _ := os.ReadFile("photo.jpg")
    pdf2, _ := pdfoxide.FromImageBytes(data)
    _ = pdf2.Save("photo.pdf")
    pdf2.Close()
}

Java

import fyi.oxide.pdf.Pdf;
import java.nio.file.*;
import java.util.List;

// Single image (one byte array → one-page PDF)
byte[] photo = Files.readAllBytes(Path.of("photo.jpg"));
try (Pdf pdf = Pdf.fromImages(List.of(photo))) {
    pdf.saveTo(Path.of("photo.pdf"));
}

// Multiple images (each byte array becomes a page)
List<byte[]> pages = List.of(
    Files.readAllBytes(Path.of("page1.jpg")),
    Files.readAllBytes(Path.of("page2.png")),
    Files.readAllBytes(Path.of("page3.jpg")));
try (Pdf album = Pdf.fromImages(pages)) {
    album.saveTo(Path.of("album.pdf"));
}

Ruby

require 'pdf_oxide'

# Single image (one byte blob → one-page PDF)
photo = File.binread('photo.jpg')
PdfOxide::Pdf.from_images([photo]) { |pdf| pdf.save('photo.pdf') }

# Multiple images (each blob becomes a page)
pages = ['page1.jpg', 'page2.png', 'page3.jpg'].map { |f| File.binread(f) }
PdfOxide::Pdf.from_images(pages) { |album| album.save('album.pdf') }

C++

#include <pdf_oxide/pdf_oxide.hpp>

// Single image from a path
auto pdf = pdf_oxide::Pdf::from_image("photo.jpg");
pdf.save("photo.pdf");

// From in-memory image bytes
auto bytes = /* std::vector<std::uint8_t> from "photo.jpg" */;
auto pdf2 = pdf_oxide::Pdf::from_image_bytes(bytes);
pdf2.save("photo.pdf");

Swift

import PdfOxide

// Single image from a path
let pdf = try Pdf.fromImage("photo.jpg")
try pdf.save("photo.pdf")

// From in-memory image bytes
let bytes = [UInt8](try Data(contentsOf: URL(fileURLWithPath: "photo.jpg")))
let pdf2 = try Pdf.fromImageBytes(bytes)
try pdf2.save("photo.pdf")

Dart

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

// Single image from a path
final pdf = Pdf.fromImage('photo.jpg');
pdf.save('photo.pdf');

// From in-memory image bytes
final bytes = File('photo.jpg').readAsBytesSync();
final pdf2 = Pdf.fromImageBytes(bytes);
pdf2.save('photo.pdf');

R

library(pdfoxide)

# Single image from a path
pdf <- pdf_from_image("photo.jpg")
pdf_save(pdf, "photo.pdf")

# From in-memory image bytes
bytes <- readBin("photo.jpg", what = "raw", n = file.info("photo.jpg")$size)
pdf2 <- pdf_from_image_bytes(bytes)
pdf_save(pdf2, "photo.pdf")

Julia

using PdfOxide

# Single image from a path
pdf = from_image("photo.jpg")
save(pdf, "photo.pdf")

# From in-memory image bytes
bytes = read("photo.jpg")
pdf2 = from_image_bytes(bytes)
save(pdf2, "photo.pdf")

Zig

const pdf_oxide = @import("pdf_oxide");

// Single image from a path
var pdf = try pdf_oxide.Pdf.fromImage("photo.jpg");
try pdf.save("photo.pdf");

// From in-memory image bytes
var pdf2 = try pdf_oxide.Pdf.fromImageBytes(image_bytes);
try pdf2.save("photo.pdf");

Objective-C

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

// Single image from a path
POXPdf *pdf = [POXPdf fromImage:@"photo.jpg" error:&err];
[pdf saveToPath:@"photo.pdf" error:&err];

// From in-memory image bytes
NSData *data = [NSData dataWithContentsOfFile:@"photo.jpg"];
POXPdf *pdf2 = [POXPdf fromImageBytes:data error:&err];
[pdf2 saveToPath:@"photo.pdf" error:&err];

Elixir

# Single image from a path
{:ok, pdf} = PdfOxide.from_image("photo.jpg")
PdfOxide.save(pdf, "photo.pdf")

# From in-memory image bytes
{:ok, pdf2} = PdfOxide.from_image_bytes(File.read!("photo.jpg"))
PdfOxide.save(pdf2, "photo.pdf")

C# 支持。 C# 的 Pdf 类目前提供 Pdf.FromMarkdown、Pdf.FromHtml 和 Pdf.FromText——图像转 PDF 的功能尚未封装到公开的 C# API 中。在 C# 流程中从图像生成 PDF 时，请通过 Rust CLI（pdf-oxide from-image photo.jpg）调用，或桥接到 Go/Python。

完整 API 参考

Pdf::from_image(path) – 单张图像

从图像文件创建单页 PDF。在保持纵横比的同时，页面尺寸会被调整以适应所配置的页面尺寸范围内的图像。

Rust:

use pdf_oxide::api::Pdf;

let pdf = Pdf::from_image("diagram.png")?;
pdf.save("diagram.pdf")?;

Python:

pdf = Pdf.from_image("diagram.png")
pdf.save("diagram.pdf")

C++:

#include <pdf_oxide/pdf_oxide.hpp>

auto pdf = pdf_oxide::Pdf::from_image("diagram.png");
pdf.save("diagram.pdf");

Swift:

import PdfOxide

let pdf = try Pdf.fromImage("diagram.png")
try pdf.save("diagram.pdf")

Dart:

import 'package:pdf_oxide/pdf_oxide.dart';

final pdf = Pdf.fromImage('diagram.png');
pdf.save('diagram.pdf');

R:

library(pdfoxide)

pdf <- pdf_from_image("diagram.png")
pdf_save(pdf, "diagram.pdf")

Julia:

using PdfOxide

pdf = from_image("diagram.png")
save(pdf, "diagram.pdf")

Zig:

const pdf_oxide = @import("pdf_oxide");

var pdf = try pdf_oxide.Pdf.fromImage("diagram.png");
try pdf.save("diagram.pdf");

Objective-C:

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

POXPdf *pdf = [POXPdf fromImage:@"diagram.png" error:&err];
[pdf saveToPath:@"diagram.pdf" error:&err];

Elixir:

{:ok, pdf} = PdfOxide.from_image("diagram.png")
PdfOxide.save(pdf, "diagram.pdf")

Pdf::from_image_bytes(data) – 从字节创建图像

从原始图像字节创建 PDF。图像格式（JPEG 或 PNG）会根据字节内容自动检测。

Rust:

use pdf_oxide::api::Pdf;

let image_bytes = std::fs::read("photo.jpg")?;
let pdf = Pdf::from_image_bytes(&image_bytes)?;
pdf.save("photo.pdf")?;

Python:

from pdf_oxide import Pdf

with open("photo.jpg", "rb") as f:
    image_bytes = f.read()

pdf = Pdf.from_image_bytes(image_bytes)
pdf.save("photo.pdf")

JavaScript:

import { WasmPdf } from "pdf-oxide-wasm";

const imageData = new Uint8Array(readFileSync("photo.jpg"));
const pdf = WasmPdf.fromImageBytes(imageData);
writeFileSync("photo.pdf", pdf.toBytes());

Java:

import fyi.oxide.pdf.Pdf;
import java.nio.file.*;
import java.util.List;

byte[] imageBytes = Files.readAllBytes(Path.of("photo.jpg"));
try (Pdf pdf = Pdf.fromImages(List.of(imageBytes))) {
    pdf.saveTo(Path.of("photo.pdf"));
}

Ruby:

require 'pdf_oxide'

image_bytes = File.binread('photo.jpg')
PdfOxide::Pdf.from_images([image_bytes]) { |pdf| pdf.save('photo.pdf') }

C++:

#include <pdf_oxide/pdf_oxide.hpp>

// image_bytes: std::vector<std::uint8_t> read from "photo.jpg"
auto pdf = pdf_oxide::Pdf::from_image_bytes(image_bytes);
pdf.save("photo.pdf");

Swift:

import PdfOxide

let imageBytes = [UInt8](try Data(contentsOf: URL(fileURLWithPath: "photo.jpg")))
let pdf = try Pdf.fromImageBytes(imageBytes)
try pdf.save("photo.pdf")

Dart:

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

final imageBytes = File('photo.jpg').readAsBytesSync();
final pdf = Pdf.fromImageBytes(imageBytes);
pdf.save('photo.pdf');

R:

library(pdfoxide)

image_bytes <- readBin("photo.jpg", what = "raw", n = file.info("photo.jpg")$size)
pdf <- pdf_from_image_bytes(image_bytes)
pdf_save(pdf, "photo.pdf")

Julia:

using PdfOxide

image_bytes = read("photo.jpg")
pdf = from_image_bytes(image_bytes)
save(pdf, "photo.pdf")

Zig:

const pdf_oxide = @import("pdf_oxide");

var pdf = try pdf_oxide.Pdf.fromImageBytes(image_bytes);
try pdf.save("photo.pdf");

Objective-C:

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

NSData *imageBytes = [NSData dataWithContentsOfFile:@"photo.jpg"];
POXPdf *pdf = [POXPdf fromImageBytes:imageBytes error:&err];
[pdf saveToPath:@"photo.pdf" error:&err];

Elixir:

{:ok, pdf} = PdfOxide.from_image_bytes(File.read!("photo.jpg"))
PdfOxide.save(pdf, "photo.pdf")

WasmPdf.fromMultipleImageBytes(imagesArray) – 从字节创建多张图像

从图像字节数组的数组创建多页 PDF。每张图像成为单独的一页。仅在 JavaScript/WASM 中可用。

JavaScript:

import { WasmPdf } from "pdf-oxide-wasm";

const images = ["scan_001.jpg", "scan_002.jpg", "scan_003.jpg"]
  .map(f => new Uint8Array(readFileSync(f)));
const pdf = WasmPdf.fromMultipleImageBytes(images);
writeFileSync("scanned_document.pdf", pdf.toBytes());

Pdf::from_images(paths) – 多张图像

创建多页 PDF，其中每张图像成为单独的一页。每一页都会单独调整尺寸，以匹配各张图像的尺寸和纵横比。

Rust:

use pdf_oxide::api::Pdf;

let pages = vec!["scan_001.jpg", "scan_002.jpg", "scan_003.jpg"];
let pdf = Pdf::from_images(&pages)?;
pdf.save("scanned_document.pdf")?;

Python:

from pdf_oxide import Pdf

pages = ["scan_001.jpg", "scan_002.jpg", "scan_003.jpg"]
pdf = Pdf.from_images(pages)
pdf.save("scanned_document.pdf")

Java:

import fyi.oxide.pdf.Pdf;
import java.nio.file.*;
import java.util.List;

// fromImages takes the bytes of each image; each becomes a page.
List<byte[]> pages = List.of(
    Files.readAllBytes(Path.of("scan_001.jpg")),
    Files.readAllBytes(Path.of("scan_002.jpg")),
    Files.readAllBytes(Path.of("scan_003.jpg")));
try (Pdf pdf = Pdf.fromImages(pages)) {
    pdf.saveTo(Path.of("scanned_document.pdf"));
}

Ruby:

require 'pdf_oxide'

pages = ['scan_001.jpg', 'scan_002.jpg', 'scan_003.jpg'].map { |f| File.binread(f) }
PdfOxide::Pdf.from_images(pages) { |pdf| pdf.save('scanned_document.pdf') }

配合 PdfBuilder 使用图像

使用 PdfBuilder 可在创建图像 PDF 时控制页面尺寸和边距。

Rust:

use pdf_oxide::api::PdfBuilder;
use pdf_oxide::writer::PageSize;

let pdf = PdfBuilder::new()
    .title("Photo Album")
    .author("Photographer")
    .page_size(PageSize::A4)
    .margin(36.0)  // 0.5 inch margins
    .from_image("photo.jpg")?;

pdf.save("photo_a4.pdf")?;

配合构建器使用多张图像：

use pdf_oxide::api::PdfBuilder;
use pdf_oxide::writer::PageSize;

let pdf = PdfBuilder::new()
    .title("Document Scans")
    .page_size(PageSize::Letter)
    .from_images(&["page1.png", "page2.png"])?;

pdf.save("scans.pdf")?;

进阶示例

批量转换某个目录中的图像

use pdf_oxide::api::Pdf;
use std::fs;

let mut images: Vec<String> = fs::read_dir("./photos")?
    .filter_map(|entry| {
        let path = entry.ok()?.path();
        let ext = path.extension()?.to_str()?.to_lowercase();
        if ext == "jpg" || ext == "jpeg" || ext == "png" {
            Some(path.to_string_lossy().to_string())
        } else {
            None
        }
    })
    .collect();

images.sort();

let pdf = Pdf::from_images(&images)?;
pdf.save("all_photos.pdf")?;

Python：转换某个目录中的图像

from pdf_oxide import Pdf
from pathlib import Path

image_dir = Path("./scans")
images = sorted(
    str(p) for p in image_dir.iterdir()
    if p.suffix.lower() in (".jpg", ".jpeg", ".png")
)

pdf = Pdf.from_images(images)
pdf.save("scans.pdf")

从下载的图像字节创建 PDF

from pdf_oxide import Pdf
import urllib.request

url = "https://example.com/chart.png"
image_data = urllib.request.urlopen(url).read()

pdf = Pdf.from_image_bytes(image_data)
pdf.save("chart.pdf")

JavaScript：在浏览器中转换多张图像

import { WasmPdf } from "pdf-oxide-wasm";

async function imagesToPdf(fileList) {
  const images = [];
  for (const file of fileList) {
    const buffer = await file.arrayBuffer();
    images.push(new Uint8Array(buffer));
  }
  const pdf = WasmPdf.fromMultipleImageBytes(images);
  return pdf.toBytes();
}

支持的格式

格式	扩展名	说明
JPEG	.jpg, .jpeg	有损压缩，最适合照片
PNG	.png	无损压缩，支持透明

相关页面

• PdfBuilder 流式 API – 配置页面尺寸、边距和元数据
• 二维码和条形码 – 将条形码图像生成为 PDF
• 从 Markdown 创建 – 将文本内容转换为 PDF