Skip to content
PDF Oxide

PDF aus Bildern erstellen

Wandeln Sie Bilder in PDF-Dokumente um. Jedes Bild wird zu einer Seite, deren Größe so angepasst wird, dass das Bild bei gleichbleibendem Seitenverhältnis vollständig dargestellt wird. JPEG und PNG werden unterstützt.

Schnellbeispiel

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#-Unterstützung. Die C#-Klasse Pdf bietet derzeit Pdf.FromMarkdown, Pdf.FromHtml und Pdf.FromText — die Erstellung von PDFs aus Bildern ist noch nicht in der öffentlichen C#-API verfügbar. Verwenden Sie in C#-Pipelines die Rust-CLI (pdf-oxide from-image photo.jpg) oder leiten Sie die Anfrage an Go/Python weiter.

Vollständige API-Referenz

Pdf::from_image(path) – Einzelbild

Erstellt ein einseitiges PDF aus einer Bilddatei. Die Seitengröße wird so angepasst, dass das Bild unter Beibehaltung des Seitenverhältnisses in die konfigurierten Seitenmaße passt.

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) – Bild aus Bytes

Erstellt ein PDF aus rohen Bildbytes. Das Bildformat (JPEG oder PNG) wird automatisch anhand des Byte-Inhalts erkannt.

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) – Mehrere Bilder aus Bytes

Erstellt ein mehrseitiges PDF aus einem Array von Bild-Byte-Arrays. Jedes Bild wird zu einer eigenen Seite. Nur in JavaScript/WASM verfügbar.

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) – Mehrere Bilder

Erstellt ein mehrseitiges PDF, bei dem jedes Bild zu einer eigenen Seite wird. Die Seitengröße wird für jedes Bild individuell an dessen Abmessungen und Seitenverhältnis angepasst.

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 mit Bildern verwenden

Mit PdfBuilder können Sie beim Erstellen von Bild-PDFs Seitengröße und Ränder steuern.

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")?;

Mehrere Bilder mit Builder:

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")?;

Erweiterte Beispiele

Alle Bilder in einem Verzeichnis stapelweise konvertieren

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: Bilder aus einem Verzeichnis konvertieren

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 aus heruntergeladenen Bildbytes erstellen

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: Mehrere Bilder im Browser konvertieren

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();
}

Unterstützte Formate

Format Endungen Hinweise
JPEG .jpg, .jpeg Verlustbehaftete Komprimierung, ideal für Fotos
PNG .png Verlustfrei, unterstützt Transparenz

Verwandte Seiten