Skip to content
PDF Oxide

Створення PDF із зображень

Перетворюйте зображення на 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#. Клас Pdf у C# наразі надає методи Pdf.FromMarkdown, Pdf.FromHtml і Pdf.FromText — створення PDF із зображень ще не реалізовано у публічному C# API. Для генерації PDF із зображень у C#-конвеєрі використовуйте 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 Без втрат, підтримує прозорість

Пов’язані сторінки