QR-Codes & Barcodes

Erzeugen Sie QR-Codes und 1D-Barcodes direkt als PDF-Dokumente, als eigenständige PNG-/SVG-Bilder oder platzieren Sie sie auf Seiten eines bestehenden PDFs. Die Barcode-Erzeugung liegt hinter einem Feature-Flag, damit die Kernbibliothek schlank bleibt.

Abdeckung in den Bindings. Es gibt zwei verschiedene Barcode-Oberflächen:

1. Einschritt-PDF-Konstruktoren (Pdf::from_qrcode / Pdf::from_barcode) und der Low-Level-BarcodeGenerator – nur in Rust verfügbar.
2. Die Barcode-Bild-Handle-Familie (generate_qr_code, generate_barcode, add_barcode_to_page), gestützt auf die C-ABI-Funktionen pdf_generate_qr_code / pdf_generate_barcode / pdf_add_barcode_to_page – verfügbar in Swift, Go und C# und direkt aus C/C++ über FFI aufrufbar.
3. SVG-Generatoren (generate_qr_svg / generate_barcode_svg) – verfügbar in Python und Rust.

Jede Methode unten ist mit den Sprachen gekennzeichnet, die sie tatsächlich bereitstellen. Gehen Sie nicht davon aus, dass eine Methode in einer Binding existiert, in der sie nicht aufgeführt ist.

Erfordert das Feature-Flag: barcodes

# Cargo.toml
[dependencies]
pdf_oxide = { version = "0.3", features = ["barcodes"] }

Wie erzeuge ich einen QR-Code als PDF?

Der schnellste Weg in Rust ist der Einschritt-Konstruktor Pdf::from_qrcode. pdf_oxide schreibt den QR-Code in ein einseitiges PDF, das Sie direkt speichern können.

Rust:

use pdf_oxide::api::Pdf;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // QR code (300px) -> single-page PDF
    let pdf = Pdf::from_qrcode("https://example.com")?;
    pdf.save("qrcode.pdf")?;

    // 1D barcode -> single-page PDF
    use pdf_oxide::writer::barcode::BarcodeType;
    let pdf = Pdf::from_barcode(BarcodeType::Code128, "ABC-12345")?;
    pdf.save("barcode.pdf")?;
    Ok(())
}

Wie erzeuge ich ein Barcode-Bild (PNG/SVG) statt eines PDFs?

Wenn Sie das kodierte Glyph als Bild benötigen – zum Einbetten in ein bestehendes Dokument, zum Ausliefern an ein Web-Frontend oder zum Drucken auf einem Etikett – verwenden Sie die Bild-Handle-Familie oder die SVG-Generatoren. Dies sind die kanonischen Methodennamen: generate_qr_code und generate_barcode (die älteren Namen generate_qr / generate_code gehören nicht zur öffentlichen Oberfläche).

Swift (BarcodeImage.generateQrCode, BarcodeImage.generateBarcode):

import PdfOxide

// QR code. errorCorrection: 0=L 1=M 2=Q 3=H. sizePx: module-grid pixel size.
let qr = try BarcodeImage.generateQrCode("https://example.com",
                                         errorCorrection: 1, sizePx: 256)
let pngBytes = try qr.imagePng(sizePx: 256)   // [UInt8]
let svg      = try qr.svg(sizePx: 256)        // String
qr.close()

// 1D barcode. format: 0=Code128 1=Code39 2=EAN13 3=EAN8 4=UPCA 5=ITF 6=Code93 7=Codabar.
let bc = try BarcodeImage.generateBarcode("5901234123457", format: 2, sizePx: 256)
let barcodePng = try bc.imagePng(sizePx: 256)
bc.close()

Go (GenerateQRCode, GenerateBarcode):

package main

import (
	"os"

	pdfoxide "github.com/yfedoseev/pdf_oxide/go"
)

func main() {
	// QR code. errorCorrection: 0=Low 1=Medium 2=Quartile 3=High.
	qr, err := pdfoxide.GenerateQRCode("https://example.com", 1, 256)
	if err != nil {
		panic(err)
	}
	defer qr.Close()
	svg, _ := qr.SVGData()
	_ = os.WriteFile("qr.svg", []byte(svg), 0o644)

	// 1D barcode. format: 0=Code128 1=Code39 2=EAN13 3=EAN8 4=UPCA 5=ITF 6=Code93 7=Codabar.
	bc, err := pdfoxide.GenerateBarcode("5901234123457", 2, 300)
	if err != nil {
		panic(err)
	}
	defer bc.Close()
	png, _ := bc.PNGData()
	_ = os.WriteFile("ean13.png", png, 0o644)
}

C# (Barcode.GenerateQrCode, Barcode.Generate):

using PdfOxide;

// QR code. errorCorrection: 0=L 1=M 2=Q 3=H. sizePx default 300.
using var qr = Barcode.GenerateQrCode("https://example.com", errorCorrection: 1, sizePx: 256);
byte[] qrPng = qr.ToPng(256);
string qrSvg = qr.ToSvg();

// 1D barcode. BarcodeFormat: Code128, Code39, Ean13, Ean8, UpcA, Itf.
using var bc = Barcode.Generate("5901234123457", BarcodeFormat.Ean13, sizePx: 300);
byte[] eanPng = bc.ToPng(300);

Python (generate_qr_svg, generate_barcode_svg – nur SVG):

import pdf_oxide

# QR code SVG. error_correction: 0=Low, 1=Medium, 2=Quartile, 3=High. size in px.
qr_svg = pdf_oxide.generate_qr_svg("https://example.com", 1, 256)
with open("qr.svg", "w") as f:
    f.write(qr_svg)

# 1D barcode SVG. barcode_type: 0=Code128, 1=Code39, 2=EAN13, 3=EAN8,
#                                4=UPCA, 5=ITF, 6=Code93, 7=Codabar.
ean_svg = pdf_oxide.generate_barcode_svg(2, "5901234123457")
with open("ean13.svg", "w") as f:
    f.write(ean_svg)

Wie füge ich einen Barcode zu einer Seite eines bestehenden PDFs hinzu?

Verwenden Sie add_barcode_to_page, um ein erzeugtes Barcode-Bild an einer gegebenen Position und Größe auf einer (0-basierten) Seite eines DocumentEditor zu platzieren und anschließend zu speichern. Dies ist in Swift idiomatisch als DocumentEditor.addBarcodeToPage und direkt über die C-ABI als pdf_add_barcode_to_page verfügbar. Die Bild-Handle-Familie, von der es abhängt, ist in den Editor-Klassen von Go/C# nicht gekapselt; verwenden Sie daher Swift (oder rufen Sie die C-ABI aus C/C++ auf) für die Platzierung an Ort und Stelle.

Swift (DocumentEditor.addBarcodeToPage):

import PdfOxide

let editor = try DocumentEditor.openFromBytes(try Data(contentsOf: inputURL).map { $0 })

// Generate the barcode image, then stamp it onto page 0 (PDF user-space points).
let qr = try BarcodeImage.generateQrCode("https://example.com/track/42", sizePx: 128)
try editor.addBarcodeToPage(0, qr, x: 36, y: 36, width: 96, height: 96)

let outBytes = try editor.saveToBytes()
qr.close()
editor.close()

C-ABI (pdf_add_barcode_to_page):

#include "pdf_oxide.h"

int err = 0;

// Build a barcode handle (QR shown; use pdf_generate_barcode for 1D).
FfiBarcodeImage *qr = pdf_generate_qr_code("https://example.com/track/42",
                                           /*error_correction=*/1,
                                           /*size_px=*/128, &err);

// Place it on page 0 at (x, y) sized width x height (PDF user-space points).
pdf_add_barcode_to_page(editor, /*page_index=*/0, qr,
                        /*x=*/36.0f, /*y=*/36.0f,
                        /*width=*/96.0f, /*height=*/96.0f, &err);

pdf_barcode_free(qr);

Methodensignaturen

Einschritt-PDF-Konstruktoren – nur Rust

// QR code, 300px default size:
Pdf::from_qrcode(data: &str) -> Result<Pdf>
Pdf::from_qrcode_with_options(data: &str, options: &QrCodeOptions) -> Result<Pdf>

// 1D barcode, 200x80 default size:
Pdf::from_barcode(barcode_type: BarcodeType, data: &str) -> Result<Pdf>
Pdf::from_barcode_with_options(barcode_type: BarcodeType, data: &str,
                               options: &BarcodeOptions) -> Result<Pdf>

Barcode-Bild-Handle-Familie – Swift / Go / C# / C-ABI

Sprache	QR-Generator	1D-Generator	Auf Seite platzieren
Swift	BarcodeImage.generateQrCode(_ data:, errorCorrection: Int32 = 1, sizePx: Int32 = 256)	BarcodeImage.generateBarcode(_ data:, format: Int32, sizePx: Int32 = 256)	DocumentEditor.addBarcodeToPage(_ page:, _ barcode:, x:, y:, width:, height:)
Go	GenerateQRCode(data string, errorCorrection int, sizePx int) (*BarcodeImage, error)	GenerateBarcode(data string, format int, sizePx int) (*BarcodeImage, error)	– (nicht im Editor gekapselt)
C#	Barcode.GenerateQrCode(string data, int errorCorrection = 1, int sizePx = 300)	Barcode.Generate(string data, BarcodeFormat format = Code128, int sizePx = 300)	– (nicht im Editor gekapselt)
C-ABI	pdf_generate_qr_code(const char *data, int32_t error_correction, int32_t size_px, int32_t *error_code)	pdf_generate_barcode(const char *data, int32_t format, int32_t size_px, int32_t *error_code)	pdf_add_barcode_to_page(DocumentEditor *doc, int32_t page_index, const FfiBarcodeImage *barcode, float x, float y, float width, float height, int32_t *error_code)

Sobald Sie ein Barcode-Handle besitzen, können Sie dessen Nutzdaten auslesen und es rendern:

Operation	Swift	Go	C#	C-ABI
PNG-Bytes	imagePng(sizePx:)	PNGData()	ToPng(sizePx)	pdf_barcode_get_image_png
SVG-String	svg(sizePx:)	SVGData()	ToSvg()	pdf_barcode_get_svg
Dekodierte Daten	data()	SourceData()	Data	pdf_barcode_get_data
Formatcode	format()	—	Format	pdf_barcode_get_format
Handle freigeben	close()	Close()	Dispose()	pdf_barcode_free

SVG-Generatoren – Python / Rust

# Python free functions (require the barcodes feature in the wheel):
generate_qr_svg(data: str, error_correction: int, size: int) -> str
generate_barcode_svg(barcode_type: int, data: str) -> str

Rust: vollständige API-Referenz

QR-Code-Erzeugung

Pdf::from_qrcode(data) – Standard-QR-Code

Erstellt ein einseitiges PDF mit einem 300px großen QR-Code.

use pdf_oxide::api::Pdf;

let pdf = Pdf::from_qrcode("https://example.com")?;
pdf.save("qr.pdf")?;

Pdf::from_qrcode_with_options(data, options) – benutzerdefinierter QR-Code

Volle Kontrolle über Größe, Fehlerkorrektur, Farben und Ruhezone.

use pdf_oxide::api::Pdf;
use pdf_oxide::writer::barcode::{QrCodeOptions, QrErrorCorrection};

let options = QrCodeOptions::new()
    .size(400)
    .error_correction(QrErrorCorrection::High)
    .quiet_zone(6)
    .foreground(0, 0, 128, 255)          // Navy blue
    .background(255, 255, 255, 255);     // White

let pdf = Pdf::from_qrcode_with_options("https://example.com", &options)?;
pdf.save("custom_qr.pdf")?;

QrCodeOptions – QR-Konfiguration

Methode	Standard	Beschreibung
.size(px)	200	QR-Code-Größe in Pixeln
.error_correction(level)	Medium	Fehlerkorrekturstufe
.quiet_zone(modules)	4	Randbreite in Modulen
.foreground(r, g, b, a)	Black (0,0,0,255)	Modulfarbe (RGBA)
.background(r, g, b, a)	White (255,255,255,255)	Hintergrundfarbe (RGBA)

Enum QrErrorCorrection

Variante	Wiederherstellungskapazität	Anwendungsfall	Ganzzahl (FFI)
Low	~7 %	Maximale Datendichte	0
Medium	~15 %	Allzweck (Standard)	1
Quartile	~25 %	Etiketten, die beschädigt werden können	2
High	~30 %	Industrie / raue Umgebungen	3

Erzeugung von 1D-Barcodes

Pdf::from_barcode(barcode_type, data) – Standard-Barcode

Erstellt ein einseitiges PDF mit einem Barcode in der Standardgröße (200x80).

use pdf_oxide::api::Pdf;
use pdf_oxide::writer::barcode::BarcodeType;

let pdf = Pdf::from_barcode(BarcodeType::Ean13, "5901234123457")?;
pdf.save("product.pdf")?;

Pdf::from_barcode_with_options(barcode_type, data, options) – benutzerdefinierter Barcode

Volle Kontrolle über die Abmessungen und Farben des Barcodes.

use pdf_oxide::api::Pdf;
use pdf_oxide::writer::barcode::{BarcodeType, BarcodeOptions};

let options = BarcodeOptions::new()
    .width(400)
    .height(120)
    .foreground(0, 0, 0, 255)
    .background(255, 255, 255, 255);

let pdf = Pdf::from_barcode_with_options(
    BarcodeType::Code128,
    "SHIP-2025-00042",
    &options,
)?;
pdf.save("shipping_label.pdf")?;

BarcodeOptions – 1D-Konfiguration

Methode	Standard	Beschreibung
.width(px)	200	Barcode-Breite in Pixeln
.height(px)	80	Barcode-Höhe in Pixeln
.foreground(r, g, b, a)	Black (0,0,0,255)	Balkenfarbe (RGBA)
.background(r, g, b, a)	White (255,255,255,255)	Hintergrundfarbe (RGBA)
.show_text(bool)	false	Menschenlesbaren Text anzeigen

Enum BarcodeType

Variante	Name	Datenformat	Ganzzahl (FFI)
Code128	Code 128	Alphanumerisch (wählt A/B/C automatisch)	0
Code39	Code 39	Großbuchstaben, Ziffern + Symbole	1
Ean13	EAN-13	13 Ziffern (European Article Number)	2
Ean8	EAN-8	8 Ziffern (kompaktes EAN)	3
UpcA	UPC-A	11–12 Ziffern (Universal Product Code)	4
Itf	Interleaved 2 of 5	Ziffernpaare (gerade Ziffernanzahl)	5
Code93	Code 93	Alphanumerisch (kompakt)	6
Codabar	Codabar	Ziffern + Sonderzeichen (A-D Start/Stopp)	7

Die C-ABI pdf_generate_barcode und die Go-/Swift-/C#-Wrapper wählen die Symbologie über die obige Spalte Ganzzahl (FFI). Das BarcodeFormat-Enum in C# stellt derzeit Code128–Itf (0–5) bereit.

Low-Level-BarcodeGenerator – nur Rust

Zum Erzeugen von Barcode-Bildern, ohne ein vollständiges PDF zu erstellen (z. B. zum Einbetten in ein bestehendes Dokument):

use pdf_oxide::writer::barcode::{BarcodeGenerator, BarcodeType, BarcodeOptions, QrCodeOptions};

// Generate QR code as PNG bytes
let qr_png = BarcodeGenerator::generate_qr(
    "https://example.com",
    &QrCodeOptions::default().size(256),
)?;

// Generate QR code as an SVG string
let qr_svg = BarcodeGenerator::generate_qr_svg(
    "https://example.com",
    &QrCodeOptions::default().size(256),
)?;

// Generate QR code with simple API
let qr_png = BarcodeGenerator::generate_qr_simple("https://example.com", 200)?;

// Generate 1D barcode as PNG bytes
let barcode_png = BarcodeGenerator::generate_1d(
    BarcodeType::Code128,
    "ABC123",
    &BarcodeOptions::default().width(300).height(100),
)?;

// Generate 1D barcode as an SVG string
let barcode_svg = BarcodeGenerator::generate_1d_svg(
    BarcodeType::Code128,
    "ABC123",
    &BarcodeOptions::default(),
)?;

// Convenience methods
let code128_png = BarcodeGenerator::generate_code128("DATA", 200, 80)?;
let ean13_png = BarcodeGenerator::generate_ean13("5901234123457", 200, 80)?;

PdfBuilder mit Barcodes verwenden – nur Rust

PdfBuilder bietet eine fließende Schnittstelle, um Seitengröße und Dokumentmetadaten festzulegen, bevor Barcode-PDFs erzeugt werden.

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

// QR code with custom page size
let pdf = PdfBuilder::new()
    .title("WiFi Access")
    .page_size(PageSize::Custom(300.0, 300.0))
    .from_qrcode("WIFI:T:WPA;S:MyNetwork;P:secret123;;")?;
pdf.save("wifi_qr.pdf")?;

// Barcode with metadata
let pdf = PdfBuilder::new()
    .title("Product Label")
    .author("Warehouse System")
    .from_barcode(BarcodeType::Ean13, "5901234123457")?;
pdf.save("label.pdf")?;

Fortgeschrittene Beispiele

Versandetikett mit mehreren Barcodes (Rust)

use pdf_oxide::writer::barcode::{BarcodeGenerator, QrCodeOptions, QrErrorCorrection};

// Generate barcode images, then embed via the image APIs.
let tracking_barcode = BarcodeGenerator::generate_code128(
    "1Z999AA10123456784",
    300,
    80,
)?;

let qr_bytes = BarcodeGenerator::generate_qr(
    "https://track.example.com/1Z999AA10123456784",
    &QrCodeOptions::new().size(200).error_correction(QrErrorCorrection::Medium),
)?;

// `tracking_barcode` and `qr_bytes` are PNG byte vectors ready to embed.

Produktetiketten im Stapel erzeugen (Rust)

use pdf_oxide::api::Pdf;
use pdf_oxide::writer::barcode::BarcodeType;

let products = vec![
    ("5901234123457", "Widget A"),
    ("4006381333931", "Widget B"),
    ("0012345678905", "Widget C"),
];

for (ean, name) in products {
    let pdf = Pdf::from_barcode(BarcodeType::Ean13, ean)?;
    pdf.save(format!("label_{}.pdf", name.to_lowercase().replace(' ', "_")))?;
}

Barcode-SVGs im Stapel (Python)

import pdf_oxide

items = [
    (0, "SHIP-00001"),   # Code128
    (0, "SHIP-00002"),   # Code128
    (2, "5901234123457"),  # EAN-13
    (4, "012345678905"),   # UPC-A
]

for barcode_type, data in items:
    svg = pdf_oxide.generate_barcode_svg(barcode_type, data)
    with open(f"barcode_{data}.svg", "w") as f:
        f.write(svg)

Tracking-QR-Codes auf jedes Etikett stempeln (Swift)

import PdfOxide

let editor = try DocumentEditor.openFromBytes(labelTemplateBytes)
let pageCount = try editor.pageCount()

for page in 0..<pageCount {
    let qr = try BarcodeImage.generateQrCode("https://track.example.com/\(page)", sizePx: 128)
    try editor.addBarcodeToPage(page, qr, x: 420, y: 700, width: 80, height: 80)
    qr.close()
}

let stamped = try editor.saveToBytes()
editor.close()

Feature-Flag

Das Feature barcodes zieht zwei zusätzliche Abhängigkeiten ein:

• barcoders – Kodierung von 1D-Barcodes
• qrcode – Kodierung von QR-Codes

Ohne das Feature-Flag geben alle Barcode-Methoden einen Fehler zurück, der angibt, dass das Feature erforderlich ist.

// Without the barcodes feature enabled:
let result = Pdf::from_qrcode("test");
// Returns Err("QR code generation requires the 'barcodes' feature")

FAQ

F: Die Dokumentation erwähnt generate_qr und generate_code – sind das die richtigen Namen? A: Nein. Die kanonischen öffentlichen Methodennamen sind generate_qr_code und generate_barcode (gestützt auf die C-ABI pdf_generate_qr_code / pdf_generate_barcode). Innerhalb von Rust sind die Low-Level-Hilfsfunktionen am BarcodeGenerator generate_qr und generate_1d; diese sind Rust-interne Hilfsfunktionen, nicht die bindungsübergreifende Oberfläche.

F: Kann ich native Barcodes aus Python oder Node erzeugen? A: Python stellt generate_qr_svg und generate_barcode_svg bereit, die SVG-Strings zurückgeben, die Sie einbetten oder rastern können. Für PNG-Handles und die direkte Platzierung auf einer Seite verwenden Sie die Bindings für Swift, Go oder C# oder rufen Sie die C-ABI direkt auf. Die nativen Einschritt-PDF-Konstruktoren (from_qrcode / from_barcode) sind ausschließlich in Rust verfügbar.

F: Wie platziere ich einen Barcode an einer bestimmten Position in einem bestehenden PDF? A: Erzeugen Sie das Bild-Handle (generate_qr_code / generate_barcode) und rufen Sie dann add_barcode_to_page(document, page_index, barcode, x, y, width, height) auf. Koordinaten und Größe sind in PDF-Benutzerraumpunkten angegeben, und der Seitenindex ist 0-basiert. In Swift ist dies als DocumentEditor.addBarcodeToPage gekapselt; aus C/C++ rufen Sie pdf_add_barcode_to_page auf.

F: Wie schnell ist die Erzeugung? A: Der Writer von pdf_oxide basiert auf derselben Engine, die Text mit einem Mittelwert von 0,8 ms und einer Bestehensrate von 100 % auf dem Benchmark-Korpus extrahiert, sodass das Kodieren eines QR- oder 1D-Barcodes und das Ausgeben einer Seite für Stapelverarbeitungslasten praktisch augenblicklich erfolgt.

Verwandte Seiten

• PdfBuilder Fluent API – Seitengröße und Metadaten für Barcode-PDFs konfigurieren
• Aus Bildern erstellen – Barcode-PNGs in PDFs mit mehreren Inhalten einbetten
• Grafiken, Muster und Schattierungen – Low-Level-Zeichnen für benutzerdefinierte Etikettenlayouts
• Typen & Enums – Details zum Enum BarcodeType