Skip to content
PDF Oxide

Bereichsextraktion — Inhalt aus einem bestimmten Bereich holen

Wenn Sie Rechnungen, Kontoauszüge, Steuerformulare oder andere vorlagenbasierte Layouts verarbeiten, wissen Sie meist bereits, wo die Felder stehen. Statt die gesamte Seite zu extrahieren und anschließend nach dem Wert zu suchen, richten Sie PDF Oxide direkt auf das gewünschte Rechteck und erhalten genau das zurück, was dort steht.

Die fluent API within(page, rect) liefert einen Bereich, auf dem Sie beliebige Extraktionsmethoden verketten können: extract_text(), extract_words(), extract_chars(), extract_tables().

Binding-Abdeckung. within(page, rect) ist in Python, Rust und WASM verfügbar. Go und C# bieten die entsprechenden Low-Level-Helfer (ExtractTextInRect, ExtractWordsInRect, ExtractImagesInRect) — siehe unten.

Kurzbeispiel

rect wird als (x, y, width, height) in PDF-Punkten angegeben, mit dem Ursprung unten links auf der Seite. Eine Letter-Seite misst 612 × 792 Punkte.

Python

from pdf_oxide import PdfDocument

doc = PdfDocument("invoice.pdf")

# Obere 92 Punkte von Seite 0 — typischer Kopfbereich
header = doc.within(0, (0, 700, 612, 92)).extract_text()
print(header)

Rust

use pdf_oxide::PdfDocument;
use pdf_oxide::geometry::Rect;

let mut doc = PdfDocument::open("invoice.pdf")?;
let header = doc.within(0, Rect::new(0.0, 700.0, 612.0, 92.0)).extract_text()?;
println!("{}", header);

JavaScript (WASM)

import { WasmPdfDocument } from "pdf-oxide-wasm";

const doc = new WasmPdfDocument(bytes);
const headerRegion = doc.within(0, [0, 700, 612, 92]);
console.log(headerRegion.extractText());
doc.free();

Go (Low-Level-Helfer, gleiche Wirkung)

package main

import (
    "fmt"
    "log"
    pdfoxide "github.com/yfedoseev/pdf_oxide/go"
)

func main() {
    doc, err := pdfoxide.Open("invoice.pdf")
    if err != nil { log.Fatal(err) }
    defer doc.Close()

    // ExtractTextInRect(pageIndex, x, y, width, height)
    header, _ := doc.ExtractTextInRect(0, 0, 700, 612, 92)
    fmt.Println(header)
}

C# (Low-Level-Helfer)

using PdfOxide;

using var doc = PdfDocument.Open("invoice.pdf");
string header = doc.ExtractTextInRect(0, 0, 700, 612, 92);
Console.WriteLine(header);

Verkettete Extraktion aus einem Bereich

Die within()-Form in Python / Rust / WASM erlaubt es, jede Extraktionsmethode auf demselben Bereich aufzurufen, ohne das Rechteck erneut angeben zu müssen:

Python

doc = PdfDocument("invoice.pdf")
region = doc.within(0, (400, 100, 200, 200))   # 200×200-Box unten rechts

total_text = region.extract_text()              # reiner Text
words      = region.extract_words()             # Wortdatensätze
chars      = region.extract_chars()             # Zeichendatensätze

Rust

let region = doc.within(0, Rect::new(400.0, 100.0, 200.0, 200.0));
let text  = region.extract_text()?;
let words = region.extract_words()?;

Typische Anwendungsfälle

Feldextraktion aus Rechnungen

Rechnungen enthalten in der Regel Lieferantenadresse, Rechnungsnummer und Positionstabelle an festen Stellen. Definieren Sie die Rechtecke einmal pro Vorlage:

from pdf_oxide import PdfDocument

TEMPLATES = {
    "acme_v1": {
        "invoice_no":  (450, 720,  120,  20),
        "issue_date":  (450, 700,  120,  20),
        "vendor_name": ( 50, 740,  300,  40),
        "total":       (450, 100,  120,  24),
    },
}

def parse_invoice(path, template):
    doc = PdfDocument(path)
    out = {}
    for field, rect in template.items():
        out[field] = doc.within(0, rect).extract_text().strip()
    return out

print(parse_invoice("invoice-2025-04.pdf", TEMPLATES["acme_v1"]))

Positionen aus Kontoauszügen

Die meisten Auszüge besitzen einen schmalen Buchungsbereich. Beschneiden Sie auf diesen Bereich und rufen Sie extract_words() auf, um jede Zeile in Lesereihenfolge samt Bounding Box zu erhalten:

doc = PdfDocument("statement.pdf")
for page in range(doc.page_count()):
    txn_region = doc.within(page, (36, 72, 540, 650))   # Kopf- und Fußzeile überspringen
    for w in txn_region.extract_words():
        print(f"page {page}: {w.text} at ({w.x0:.0f},{w.y0:.0f})")

Kopf- und Fußzeilen abschneiden

Wenn Sie nur den Fließtext indexieren möchten, schneiden Sie den oberen und unteren Bereich jeder Seite weg:

Rust

let mut doc = PdfDocument::open("book.pdf")?;
for i in 0..doc.page_count()? {
    let body = doc.within(i, Rect::new(0.0, 100.0, 612.0, 600.0))
                  .extract_text()?;
    // body indexieren …
}

Tabellenbereich einschränken

Wenn Sie bereits wissen, dass eine Seite eine Tabelle enthält und wo diese liegt, beschränken Sie extract_tables() auf dieses Rechteck:

Python

tables = doc.within(0, (50, 200, 500, 400)).extract_tables()
for t in tables:
    for row in t["rows"]:
        print([c["text"] for c in row["cells"]])

Koordinatenreferenz

PDF verwendet einen Ursprung unten links, gemessen in Punkten (1 pt = 1/72 Zoll). Eine Letter-Seite ist (0, 0, 612, 792). Für das obere 1-Zoll-Band schreiben Sie:

(x, y, w, h) = (0, 792 - 72, 612, 72)
             = (0, 720,      612, 72)

Kommen Sie aus der Welt der Bildkoordinaten (Ursprung oben links), müssen Sie y entsprechend spiegeln.

Um die tatsächliche MediaBox einer Seite vorab zu ermitteln:

Python

doc = PdfDocument("doc.pdf")
mb = doc.page_media_box(0)       # (llx, lly, urx, ury)

Rust

let mb = editor.get_page_media_box(0)?;   // [f32; 4]

Go / C# — Rechteck-Helfer

Go und C# stellen die fluent within()-Kette noch nicht bereit, die zugrunde liegenden Methoden sind jedoch dieselben:

Methode Go C#
Text im Rechteck doc.ExtractTextInRect(page, x, y, w, h) doc.ExtractTextInRect(page, x, y, w, h)
Wörter im Rechteck doc.ExtractWordsInRect(page, x, y, w, h) (noch nicht gebunden)
Bilder im Rechteck doc.ExtractImagesInRect(page, x, y, w, h) (noch nicht gebunden)

Wenn Sie in Go oder C# mehrere Extraktionstypen gegen dasselbe Rechteck benötigen, speichern Sie das Rechteck in Variablen und rufen Sie die Helfer nacheinander auf. Die fluent Schnittstelle folgt, sobald die Editor-API stabilisiert ist.

Verwandte Seiten