Skip to content
PDF Oxide

Crear PDF desde imágenes

Convierte imágenes en documentos PDF. Cada imagen se convierte en una página, cuyo tamaño se ajusta para encajar la imagen manteniendo su proporción. Compatible con los formatos JPEG y PNG.

Ejemplo rápido

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

Soporte de C#. La clase Pdf en C# actualmente expone Pdf.FromMarkdown, Pdf.FromHtml y Pdf.FromText — la creación de PDF desde imágenes todavía no está disponible en la API pública de C#. Usa la CLI de Rust (pdf-oxide from-image photo.jpg) o puentea a Go/Python cuando necesites generar PDFs desde imágenes en un pipeline de C#.

Referencia completa de la API

Pdf::from_image(path) – Imagen única

Crea un PDF de una sola página a partir de un archivo de imagen. El tamaño de la página se ajusta para que la imagen quepa dentro de las dimensiones configuradas, preservando la proporción.

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) – Imagen desde bytes

Crea un PDF a partir de bytes de imagen sin procesar. El formato de la imagen (JPEG o PNG) se detecta automáticamente a partir del contenido de los bytes.

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) – Múltiples imágenes desde bytes

Crea un PDF de varias páginas a partir de un array de arrays de bytes de imágenes. Cada imagen se convierte en una página independiente. Disponible solo en 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) – Múltiples imágenes

Crea un PDF de varias páginas donde cada imagen se convierte en una página independiente. Las páginas se dimensionan individualmente para adaptarse a las dimensiones y proporciones de cada imagen.

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') }

Usar PdfBuilder con imágenes

Utiliza PdfBuilder para controlar el tamaño de página y los márgenes al crear PDFs desde imágenes.

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

Múltiples imágenes con el 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")?;

Ejemplos avanzados

Convertir en lote un directorio de imágenes

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: convertir imágenes de un directorio

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

Crear PDF desde bytes de imagen descargados

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: convertir múltiples imágenes en el navegador

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

Formatos compatibles

Formato Extensiones Notas
JPEG .jpg, .jpeg Compresión con pérdida, ideal para fotos
PNG .png Sin pérdida, admite transparencia

Páginas relacionadas