画像から作成する

画像を PDF ドキュメントに変換します。各画像が 1 ページになり、アスペクト比を保ったまま画像に合わせてサイズが調整されます。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) – 単一画像

画像ファイルから 1 ページの 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 – ページサイズ、余白、メタデータを設定する
• QR コードとバーコード – バーコード画像を PDF として生成する
• Markdown から作成する – テキストコンテンツを PDF に変換する