feat: PDF importieren und annotiert exportieren
- ☰ → „PDF importieren …“ oder PDF ins Fenster ziehen: neues Notizbuch mit einer Seite je PDF-Seite, die Originalseite als Hintergrund - Querformat-Folien liegen oben auf dem A4-Blatt, darunter ist Platz für Notizen; gedrehte Seiten (/Rotate) erscheinen wie im PDF-Betrachter - Anzeige mit hayro (reines Rust) im Hintergrund-Thread, nächste Seite wird vorab gerendert - PDF-Export legt die Originalseiten als Vektorgrafik (Form-XObject via lopdf) unter Bilder und Tinte; nicht übernehmbare Seiten (z. B. verschlüsselt) werden als Bild mit 200 dpi eingebettet - Dateiformat-Version 5 (pdf_background an der Seite) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5.5
@@ -0,0 +1,383 @@
|
||||
//! Legt beim PDF-Export die Originalseiten importierter PDFs als Vektorgrafik unter die
|
||||
//! Notizen (Text bleibt scharf und auswählbar).
|
||||
//!
|
||||
//! Vorgehen: Das von printpdf erzeugte PDF wird mit `lopdf` geöffnet. Jede benötigte Seite
|
||||
//! des Quell-PDFs wird als Form-XObject (Inhalt + Ressourcen der Seite) übernommen und am
|
||||
//! Anfang der Zielseite gezeichnet, also unter Hintergrund, Bildern und Tinte.
|
||||
|
||||
use std::collections::{BTreeMap, HashMap};
|
||||
|
||||
use printpdf::lopdf::{Dictionary, Document, Object, ObjectId, Stream};
|
||||
|
||||
/// Eine Zielseite, unter die eine Seite eines Quell-PDFs gelegt wird.
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct Underlay {
|
||||
/// Seitennummer im Ziel-PDF, ab 0
|
||||
pub target_page: usize,
|
||||
/// Schlüssel des Quell-PDFs in `sources`
|
||||
pub source: String,
|
||||
/// Seitennummer im Quell-PDF, ab 0
|
||||
pub source_page: usize,
|
||||
/// Zielrechteck in PDF-Punkten (links, unten, Breite, Höhe; Ursprung unten links)
|
||||
pub rect: [f32; 4],
|
||||
}
|
||||
|
||||
/// Nicht übernommene Unterlagen samt Grund.
|
||||
pub type FailedUnderlays = Vec<(Underlay, String)>;
|
||||
|
||||
/// Affine PDF-Matrix `[a b c d e f]`: x' = a·x + c·y + e, y' = b·x + d·y + f.
|
||||
pub type Matrix = [f32; 6];
|
||||
|
||||
/// `outer ∘ inner`: erst `inner`, dann `outer` anwenden.
|
||||
pub fn compose(outer: Matrix, inner: Matrix) -> Matrix {
|
||||
let [a1, b1, c1, d1, e1, f1] = outer;
|
||||
let [a2, b2, c2, d2, e2, f2] = inner;
|
||||
[
|
||||
a1 * a2 + c1 * b2,
|
||||
b1 * a2 + d1 * b2,
|
||||
a1 * c2 + c1 * d2,
|
||||
b1 * c2 + d1 * d2,
|
||||
a1 * e2 + c1 * f2 + e1,
|
||||
b1 * e2 + d1 * f2 + f1,
|
||||
]
|
||||
}
|
||||
|
||||
/// Matrix, die den Seitenbereich `bbox` (links, unten, rechts, oben) einer um `rotate` Grad
|
||||
/// im Uhrzeigersinn gedrehten Seite so abbildet, wie ein Betrachter sie zeigt, eingepasst
|
||||
/// in `rect` (links, unten, Breite, Höhe).
|
||||
pub fn placement_matrix(bbox: [f32; 4], rotate: i64, rect: [f32; 4]) -> Matrix {
|
||||
let (w, h) = ((bbox[2] - bbox[0]).max(1e-3), (bbox[3] - bbox[1]).max(1e-3));
|
||||
let to_origin = [1.0, 0.0, 0.0, 1.0, -bbox[0], -bbox[1]];
|
||||
let (rotation, shown_w, shown_h): (Matrix, f32, f32) = match rotate.rem_euclid(360) {
|
||||
90 => ([0.0, -1.0, 1.0, 0.0, 0.0, w], h, w),
|
||||
180 => ([-1.0, 0.0, 0.0, -1.0, w, h], w, h),
|
||||
270 => ([0.0, 1.0, -1.0, 0.0, h, 0.0], h, w),
|
||||
_ => ([1.0, 0.0, 0.0, 1.0, 0.0, 0.0], w, h),
|
||||
};
|
||||
let scale = (rect[2] / shown_w).min(rect[3] / shown_h);
|
||||
let place = [scale, 0.0, 0.0, scale, rect[0], rect[1]];
|
||||
compose(place, compose(rotation, to_origin))
|
||||
}
|
||||
|
||||
/// Erbt ein Seitenattribut über die `Parent`-Kette.
|
||||
fn inherited<'a>(doc: &'a Document, page: &'a Dictionary, key: &[u8]) -> Option<&'a Object> {
|
||||
let mut node = page;
|
||||
for _ in 0..64 {
|
||||
if let Ok(value) = node.get(key) {
|
||||
return Some(value);
|
||||
}
|
||||
let parent = node.get(b"Parent").and_then(Object::as_reference).ok()?;
|
||||
node = doc.get_dictionary(parent).ok()?;
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn resolve<'a>(doc: &'a Document, object: &'a Object) -> &'a Object {
|
||||
doc.dereference(object).map(|(_, o)| o).unwrap_or(object)
|
||||
}
|
||||
|
||||
fn read_box(doc: &Document, object: Option<&Object>) -> Option<[f32; 4]> {
|
||||
let array = resolve(doc, object?).as_array().ok()?;
|
||||
let values: Vec<f32> = array
|
||||
.iter()
|
||||
.filter_map(|v| resolve(doc, v).as_float().ok())
|
||||
.collect();
|
||||
let [x0, y0, x1, y1] = <[f32; 4]>::try_from(values).ok()?;
|
||||
Some([x0.min(x1), y0.min(y1), x0.max(x1), y0.max(y1)])
|
||||
}
|
||||
|
||||
/// Baut aus einer Seite des (bereits umnummerierten) Quelldokuments ein Form-XObject.
|
||||
/// Liefert das XObject und die Matrix für die Platzierung in `rect`.
|
||||
fn page_as_form(
|
||||
doc: &Document,
|
||||
page_id: ObjectId,
|
||||
rect: [f32; 4],
|
||||
) -> Result<(Stream, Matrix), String> {
|
||||
let page = doc.get_dictionary(page_id).map_err(|e| e.to_string())?;
|
||||
let media =
|
||||
read_box(doc, inherited(doc, page, b"MediaBox")).unwrap_or([0.0, 0.0, 595.0, 842.0]);
|
||||
let bbox = match read_box(doc, inherited(doc, page, b"CropBox")) {
|
||||
// Sichtbarer Bereich: Schnitt aus Crop- und Media-Box
|
||||
Some(c) => [
|
||||
c[0].max(media[0]),
|
||||
c[1].max(media[1]),
|
||||
c[2].min(media[2]),
|
||||
c[3].min(media[3]),
|
||||
],
|
||||
None => media,
|
||||
};
|
||||
let rotate = inherited(doc, page, b"Rotate")
|
||||
.and_then(|r| resolve(doc, r).as_i64().ok())
|
||||
.unwrap_or(0);
|
||||
let resources = inherited(doc, page, b"Resources")
|
||||
.cloned()
|
||||
.unwrap_or_else(|| Object::Dictionary(Dictionary::new()));
|
||||
|
||||
// Ein einzelner Inhaltsstrom wird unverändert (samt Kompression) übernommen,
|
||||
// mehrere werden entpackt und aneinandergehängt
|
||||
let streams = doc.get_page_contents(page_id);
|
||||
let (content, filter) = match streams.as_slice() {
|
||||
[single] => {
|
||||
let stream = doc
|
||||
.get_object(*single)
|
||||
.and_then(Object::as_stream)
|
||||
.map_err(|e| e.to_string())?;
|
||||
let filter = ["Filter", "DecodeParms"]
|
||||
.into_iter()
|
||||
.filter_map(|k| Some((k, stream.dict.get(k.as_bytes()).ok()?.clone())))
|
||||
.collect::<Vec<_>>();
|
||||
(stream.content.clone(), filter)
|
||||
}
|
||||
_ => {
|
||||
let mut content = Vec::new();
|
||||
for id in streams {
|
||||
let stream = doc
|
||||
.get_object(id)
|
||||
.and_then(Object::as_stream)
|
||||
.map_err(|e| e.to_string())?;
|
||||
let data = stream
|
||||
.decompressed_content()
|
||||
.map_err(|e| format!("Inhalt nicht lesbar: {e}"))?;
|
||||
content.extend_from_slice(&data);
|
||||
content.push(b'\n');
|
||||
}
|
||||
(content, Vec::new())
|
||||
}
|
||||
};
|
||||
|
||||
let mut dict = Dictionary::new();
|
||||
dict.set("Type", Object::Name(b"XObject".to_vec()));
|
||||
dict.set("Subtype", Object::Name(b"Form".to_vec()));
|
||||
dict.set(
|
||||
"BBox",
|
||||
Object::Array(bbox.iter().map(|&v| Object::Real(v)).collect()),
|
||||
);
|
||||
dict.set("Resources", resources);
|
||||
for (key, value) in filter {
|
||||
dict.set(key, value);
|
||||
}
|
||||
Ok((
|
||||
Stream::new(dict, content),
|
||||
placement_matrix(bbox, rotate, rect),
|
||||
))
|
||||
}
|
||||
|
||||
/// Legt die Quellseiten unter die Zielseiten. `sources` enthält die Quell-PDFs als Bytes.
|
||||
/// Gibt die neuen PDF-Bytes zurück und die Underlays, die nicht übernommen werden konnten
|
||||
/// (z. B. verschlüsselte PDFs), samt Grund.
|
||||
pub fn apply_underlays(
|
||||
target_bytes: &[u8],
|
||||
underlays: &[Underlay],
|
||||
sources: &HashMap<String, Vec<u8>>,
|
||||
) -> Result<(Vec<u8>, FailedUnderlays), String> {
|
||||
let mut target = Document::load_mem(target_bytes).map_err(|e| e.to_string())?;
|
||||
let target_pages: Vec<ObjectId> = target.get_pages().into_values().collect();
|
||||
let mut failed = Vec::new();
|
||||
|
||||
// Quell-PDFs einmal laden und mit freien Objektnummern in das Ziel übernehmen
|
||||
let mut loaded: HashMap<&str, Result<BTreeMap<u32, ObjectId>, String>> = HashMap::new();
|
||||
for underlay in underlays {
|
||||
if loaded.contains_key(underlay.source.as_str()) {
|
||||
continue;
|
||||
}
|
||||
let result = (|| {
|
||||
let bytes = sources
|
||||
.get(&underlay.source)
|
||||
.ok_or_else(|| "Quell-PDF fehlt".to_string())?;
|
||||
let mut source = Document::load_mem(bytes).map_err(|e| e.to_string())?;
|
||||
if source.is_encrypted() {
|
||||
return Err("Quell-PDF ist verschlüsselt".to_string());
|
||||
}
|
||||
source.renumber_objects_with(target.max_id + 1);
|
||||
let pages = source.get_pages();
|
||||
target.max_id = target.max_id.max(source.max_id);
|
||||
// Katalog und Seitenbaum der Quelle werden nicht referenziert und beim Speichern
|
||||
// mit `prune_objects` entfernt
|
||||
target.objects.extend(source.objects);
|
||||
Ok(pages)
|
||||
})();
|
||||
loaded.insert(&underlay.source, result);
|
||||
}
|
||||
|
||||
for underlay in underlays {
|
||||
let result = (|| {
|
||||
let pages = loaded[underlay.source.as_str()]
|
||||
.as_ref()
|
||||
.map_err(Clone::clone)?;
|
||||
let source_page = *pages
|
||||
.get(&(underlay.source_page as u32 + 1))
|
||||
.ok_or_else(|| format!("Seite {} fehlt im Quell-PDF", underlay.source_page + 1))?;
|
||||
let target_page = *target_pages
|
||||
.get(underlay.target_page)
|
||||
.ok_or_else(|| "Zielseite fehlt".to_string())?;
|
||||
let (form, matrix) = page_as_form(&target, source_page, underlay.rect)?;
|
||||
let form_id = target.add_object(Object::Stream(form));
|
||||
let name = format!("InkPdf{}", form_id.0);
|
||||
add_xobject(&mut target, target_page, &name, form_id)?;
|
||||
let ops = format!(
|
||||
"q {} {} {} {} {} {} cm /{name} Do Q\n",
|
||||
matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]
|
||||
);
|
||||
prepend_content(&mut target, target_page, ops.into_bytes())
|
||||
})();
|
||||
if let Err(err) = result {
|
||||
failed.push((underlay.clone(), err));
|
||||
}
|
||||
}
|
||||
|
||||
target.prune_objects();
|
||||
// Neue, noch unkomprimierte Ströme packen (bereits gefilterte bleiben unverändert)
|
||||
target.compress();
|
||||
let mut out = Vec::new();
|
||||
target.save_to(&mut out).map_err(|e| e.to_string())?;
|
||||
Ok((out, failed))
|
||||
}
|
||||
|
||||
/// Trägt ein XObject in die Ressourcen der Seite ein.
|
||||
fn add_xobject(
|
||||
doc: &mut Document,
|
||||
page_id: ObjectId,
|
||||
name: &str,
|
||||
id: ObjectId,
|
||||
) -> Result<(), String> {
|
||||
// Ressourcen der Seite als eigenes Wörterbuch an der Seite (geerbte werden übernommen)
|
||||
let resources = {
|
||||
let page = doc.get_dictionary(page_id).map_err(|e| e.to_string())?;
|
||||
match inherited(doc, page, b"Resources").map(|r| resolve(doc, r)) {
|
||||
Some(Object::Dictionary(d)) => d.clone(),
|
||||
_ => Dictionary::new(),
|
||||
}
|
||||
};
|
||||
let mut xobjects = match resources.get(b"XObject").map(|x| resolve(doc, x)) {
|
||||
Ok(Object::Dictionary(d)) => d.clone(),
|
||||
_ => Dictionary::new(),
|
||||
};
|
||||
xobjects.set(name, Object::Reference(id));
|
||||
let mut resources = resources;
|
||||
resources.set("XObject", Object::Dictionary(xobjects));
|
||||
let page = doc
|
||||
.get_object_mut(page_id)
|
||||
.and_then(Object::as_dict_mut)
|
||||
.map_err(|e| e.to_string())?;
|
||||
page.set("Resources", Object::Dictionary(resources));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Stellt einen Inhaltsstrom an den Anfang der Seite (zeichnet also zuunterst).
|
||||
fn prepend_content(doc: &mut Document, page_id: ObjectId, content: Vec<u8>) -> Result<(), String> {
|
||||
let existing: Vec<Object> = doc
|
||||
.get_page_contents(page_id)
|
||||
.into_iter()
|
||||
.map(Object::Reference)
|
||||
.collect();
|
||||
let id = doc.add_object(Object::Stream(Stream::new(Dictionary::new(), content)));
|
||||
let mut contents = vec![Object::Reference(id)];
|
||||
contents.extend(existing);
|
||||
let page = doc
|
||||
.get_object_mut(page_id)
|
||||
.and_then(Object::as_dict_mut)
|
||||
.map_err(|e| e.to_string())?;
|
||||
page.set("Contents", Object::Array(contents));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn apply(m: Matrix, x: f32, y: f32) -> (f32, f32) {
|
||||
(m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5])
|
||||
}
|
||||
|
||||
fn close(a: (f32, f32), b: (f32, f32)) -> bool {
|
||||
(a.0 - b.0).abs() < 1e-3 && (a.1 - b.1).abs() < 1e-3
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_placement_matrix() {
|
||||
// Querformat-Folie 800 × 600 ohne Drehung in ein 400 × 300-Rechteck bei (10, 20)
|
||||
let m = placement_matrix([0.0, 0.0, 800.0, 600.0], 0, [10.0, 20.0, 400.0, 300.0]);
|
||||
assert!(close(apply(m, 0.0, 0.0), (10.0, 20.0)));
|
||||
assert!(close(apply(m, 800.0, 600.0), (410.0, 320.0)));
|
||||
|
||||
// Verschobene MediaBox
|
||||
let m = placement_matrix([100.0, 50.0, 300.0, 150.0], 0, [0.0, 0.0, 200.0, 100.0]);
|
||||
assert!(close(apply(m, 100.0, 50.0), (0.0, 0.0)));
|
||||
|
||||
// Um 90° gedrehte Hochformatseite (200 × 400) erscheint quer (400 × 200):
|
||||
// die linke untere Ecke landet links oben
|
||||
let m = placement_matrix([0.0, 0.0, 200.0, 400.0], 90, [0.0, 0.0, 400.0, 200.0]);
|
||||
assert!(close(apply(m, 0.0, 0.0), (0.0, 200.0)));
|
||||
assert!(close(apply(m, 200.0, 0.0), (0.0, 0.0)));
|
||||
assert!(close(apply(m, 0.0, 400.0), (400.0, 200.0)));
|
||||
|
||||
// 180° und 270° (= -90°)
|
||||
let m = placement_matrix([0.0, 0.0, 200.0, 400.0], 180, [0.0, 0.0, 200.0, 400.0]);
|
||||
assert!(close(apply(m, 0.0, 0.0), (200.0, 400.0)));
|
||||
let m = placement_matrix([0.0, 0.0, 200.0, 400.0], -90, [0.0, 0.0, 400.0, 200.0]);
|
||||
assert!(close(apply(m, 0.0, 0.0), (400.0, 0.0)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_apply_underlays_embeds_source_pages() {
|
||||
let source = crate::pdf_doc::tests::sample_pdf(&[(842.0, 595.0, 0), (595.0, 842.0, 0)]);
|
||||
let target = crate::pdf_doc::tests::sample_pdf(&[(595.0, 842.0, 0), (595.0, 842.0, 0)]);
|
||||
let sources = HashMap::from([("folien".to_string(), source)]);
|
||||
let underlays = vec![
|
||||
Underlay {
|
||||
target_page: 0,
|
||||
source: "folien".into(),
|
||||
source_page: 0,
|
||||
rect: [0.0, 421.0, 595.0, 421.0],
|
||||
},
|
||||
Underlay {
|
||||
target_page: 1,
|
||||
source: "folien".into(),
|
||||
source_page: 5,
|
||||
rect: [0.0, 0.0, 595.0, 842.0],
|
||||
},
|
||||
Underlay {
|
||||
target_page: 1,
|
||||
source: "fehlt".into(),
|
||||
source_page: 0,
|
||||
rect: [0.0, 0.0, 595.0, 842.0],
|
||||
},
|
||||
];
|
||||
let (bytes, failed) = apply_underlays(&target, &underlays, &sources).unwrap();
|
||||
// Fehlende Quellseite und fehlendes PDF werden gemeldet, der Rest klappt
|
||||
assert_eq!(failed.len(), 2);
|
||||
|
||||
let doc = Document::load_mem(&bytes).unwrap();
|
||||
let pages: Vec<ObjectId> = doc.get_pages().into_values().collect();
|
||||
assert_eq!(
|
||||
pages.len(),
|
||||
2,
|
||||
"Quellseiten dürfen nicht als eigene Seiten auftauchen"
|
||||
);
|
||||
let first = doc.get_page_content(pages[0]).unwrap();
|
||||
let text = String::from_utf8_lossy(&first);
|
||||
assert!(
|
||||
text.starts_with("q "),
|
||||
"Unterlage muss zuerst gezeichnet werden: {text}"
|
||||
);
|
||||
assert!(text.contains("Do Q"));
|
||||
// Ursprünglicher Seiteninhalt bleibt erhalten
|
||||
assert!(text.contains("re f"));
|
||||
|
||||
// Form-XObject mit dem Inhalt der Folie ist in den Ressourcen eingetragen
|
||||
let page = doc.get_dictionary(pages[0]).unwrap();
|
||||
let resources = page.get(b"Resources").unwrap().as_dict().unwrap();
|
||||
let xobjects = resources.get(b"XObject").unwrap().as_dict().unwrap();
|
||||
let (_, form_ref) = xobjects.iter().next().unwrap();
|
||||
let form = doc
|
||||
.get_object(form_ref.as_reference().unwrap())
|
||||
.unwrap()
|
||||
.as_stream()
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
form.dict.get(b"Subtype").unwrap().as_name().unwrap(),
|
||||
b"Form"
|
||||
);
|
||||
assert!(String::from_utf8_lossy(&form.content).contains("1 0 0 rg"));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user