haraldandClaude Opus 5.5
397bf3bfe4
The import now also accepts Saber files: .sbn2 (BSON) with its asset files next to it, .sba archives (zip with main.sbn2 and assets) and the old JSON .sbn, including the layout before format version 8 with strokes outside the pages. Taken over: strokes with pen pressure and perfect_freehand's thinning, highlighters, circle and rectangle shapes, typed text (Quill delta as one text field), images (SVG rasterized), background images and PDF pages as PDF backgrounds, paper patterns. BSON and zip are read by small built-in readers, so no new dependencies. The SVG rasterizer moved to src/import.rs. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
908 lines
33 KiB
Rust
908 lines
33 KiB
Rust
//! Import of Rnote notebooks (.rnote) (Issue #47).
|
||
//!
|
||
//! An .rnote file is gzip-compressed JSON: `{"version": "0.x.y", "data": {"engine_snapshot":
|
||
//! {...}}}`. The snapshot is Rnote's internal state without a specification, so it is read
|
||
//! leniently as JSON and only what we need is picked out; files from Rnote 0.5.10 on are
|
||
//! supported (the layout of older ones differs too much). Coordinates are pixels at the
|
||
//! document's dpi.
|
||
//!
|
||
//! Pages: fixed-size and continuous documents become one page per Rnote page (a stroke goes
|
||
//! to the page its middle lies on), infinite documents an endless notebook.
|
||
|
||
use base64::Engine;
|
||
use glam::DVec2;
|
||
use serde_json::Value;
|
||
use std::path::Path;
|
||
|
||
use crate::document::{Notebook, PageBackground};
|
||
use crate::import::{self, ImportReport, Imported};
|
||
use crate::storage::{NotebookLayout, NotebookManifest, StrokeData};
|
||
use crate::t;
|
||
use crate::text::TextFont;
|
||
|
||
/// At most this many pages are created (protects against nonsensical document sizes).
|
||
const MAX_PAGES: usize = 2000;
|
||
|
||
/// Is the file by its name an Rnote notebook?
|
||
pub fn is_rnote_path(path: &Path) -> bool {
|
||
path.extension()
|
||
.and_then(|e| e.to_str())
|
||
.is_some_and(|e| e.eq_ignore_ascii_case("rnote"))
|
||
}
|
||
|
||
/// Parsed Rnote document, still in Rnote pixels.
|
||
#[derive(Debug, Clone, PartialEq)]
|
||
pub struct RnoteDocument {
|
||
/// Page size in pixels and dpi
|
||
pub format: DVec2,
|
||
pub dpi: f64,
|
||
/// Document bounds (upper left corner and size)
|
||
pub origin: DVec2,
|
||
pub size: DVec2,
|
||
pub endless: bool,
|
||
pub background: PageBackground,
|
||
/// In drawing order
|
||
pub items: Vec<RnoteItem>,
|
||
}
|
||
|
||
#[derive(Debug, Clone, PartialEq)]
|
||
pub enum RnoteItem {
|
||
Ink {
|
||
color: [f32; 4],
|
||
highlighter: bool,
|
||
points: Vec<DVec2>,
|
||
/// Drawn width per point
|
||
widths: Vec<f64>,
|
||
},
|
||
Text {
|
||
content: String,
|
||
size: f64,
|
||
mono: bool,
|
||
/// Upper left corner and axes
|
||
affine: [DVec2; 3],
|
||
max_width: Option<f64>,
|
||
color: [f32; 4],
|
||
},
|
||
Bitmap {
|
||
width: u32,
|
||
height: u32,
|
||
/// Straight (not premultiplied) RGBA
|
||
pixels: Vec<u8>,
|
||
corners: [DVec2; 4],
|
||
},
|
||
/// SVG image (Rnote stores imported PDF pages like this), rasterized on import
|
||
Svg { svg: String, corners: [DVec2; 4] },
|
||
/// Element without a counterpart or unreadable
|
||
Unsupported,
|
||
}
|
||
|
||
impl RnoteItem {
|
||
/// Point that decides which page the element belongs to.
|
||
fn anchor(&self) -> Option<DVec2> {
|
||
match self {
|
||
RnoteItem::Ink { points, .. } => {
|
||
let (min, max) = points.iter().fold(
|
||
(DVec2::splat(f64::MAX), DVec2::splat(f64::MIN)),
|
||
|(a, b), &p| (a.min(p), b.max(p)),
|
||
);
|
||
(!points.is_empty()).then(|| (min + max) / 2.0)
|
||
}
|
||
RnoteItem::Text { affine, .. } => Some(affine[2]),
|
||
RnoteItem::Bitmap { corners, .. } | RnoteItem::Svg { corners, .. } => {
|
||
Some((corners[0] + corners[2]) / 2.0)
|
||
}
|
||
RnoteItem::Unsupported => None,
|
||
}
|
||
}
|
||
}
|
||
|
||
fn num(value: &Value, key: &str) -> Option<f64> {
|
||
value.get(key)?.as_f64().filter(|v| v.is_finite())
|
||
}
|
||
|
||
/// Vectors are stored as `[x, y]` (older versions possibly as `{"x": .., "y": ..}`).
|
||
fn vec2(value: &Value) -> Option<DVec2> {
|
||
match value {
|
||
Value::Array(a) if a.len() == 2 => Some(DVec2::new(a[0].as_f64()?, a[1].as_f64()?)),
|
||
Value::Object(_) => Some(DVec2::new(num(value, "x")?, num(value, "y")?)),
|
||
_ => None,
|
||
}
|
||
.filter(|v| v.is_finite())
|
||
}
|
||
|
||
/// Affine transformation as x axis, y axis and translation. Since Rnote 0.15 `affine` holds
|
||
/// the six values; before, `transform.affine` held a column-major 3×3 matrix.
|
||
fn affine(value: &Value) -> Option<[DVec2; 3]> {
|
||
let values = value
|
||
.get("affine")
|
||
.or_else(|| value.get("transform")?.get("affine"))?
|
||
.as_array()?;
|
||
let v: Vec<f64> = values.iter().filter_map(Value::as_f64).collect();
|
||
let [a, b, c, d, e, f] = match v.len() {
|
||
6 => [v[0], v[1], v[2], v[3], v[4], v[5]],
|
||
9 => [v[0], v[1], v[3], v[4], v[6], v[7]],
|
||
_ => return None,
|
||
};
|
||
Some([DVec2::new(a, b), DVec2::new(c, d), DVec2::new(e, f)])
|
||
}
|
||
|
||
fn apply(affine: &[DVec2; 3], p: DVec2) -> DVec2 {
|
||
affine[0] * p.x + affine[1] * p.y + affine[2]
|
||
}
|
||
|
||
fn color(value: Option<&Value>) -> Option<[f32; 4]> {
|
||
let value = value.filter(|v| v.is_object())?;
|
||
let c = |k| num(value, k).unwrap_or(0.0).clamp(0.0, 1.0) as f32;
|
||
Some([
|
||
c("r"),
|
||
c("g"),
|
||
c("b"),
|
||
num(value, "a").map_or(1.0, |a| a.clamp(0.0, 1.0) as f32),
|
||
])
|
||
}
|
||
|
||
/// The one variant of an externally tagged enum: `{"name": {...}}`.
|
||
fn variant(value: &Value) -> Option<(&str, &Value)> {
|
||
let object = value.as_object()?;
|
||
let (name, inner) = object.iter().next()?;
|
||
Some((name.as_str(), inner))
|
||
}
|
||
|
||
/// Width for the pressure according to Rnote's pressure curve.
|
||
fn curve_width(curve: &str, width: f64, pressure: f64) -> f64 {
|
||
let p = pressure.clamp(0.0, 1.0);
|
||
match curve {
|
||
"const" => width,
|
||
"sqrt" => width * p.sqrt(),
|
||
"cbrt" => width * p.cbrt(),
|
||
"pow2" => width * p.powi(2),
|
||
"pow3" => width * p.powi(3),
|
||
_ => width * p,
|
||
}
|
||
}
|
||
|
||
/// Style options (smooth, rough or textured).
|
||
struct Style {
|
||
width: f64,
|
||
stroke_color: Option<[f32; 4]>,
|
||
fill_color: Option<[f32; 4]>,
|
||
pressure_curve: String,
|
||
}
|
||
|
||
fn style(value: Option<&Value>) -> Option<Style> {
|
||
let (kind, options) = variant(value?)?;
|
||
let curve = if kind == "rough" {
|
||
"const".to_string()
|
||
} else {
|
||
options
|
||
.get("pressure_curve")
|
||
.and_then(Value::as_str)
|
||
.unwrap_or("linear")
|
||
.to_string()
|
||
};
|
||
Some(Style {
|
||
width: num(options, "stroke_width").unwrap_or(1.0).max(0.1),
|
||
stroke_color: color(options.get("stroke_color")),
|
||
fill_color: color(options.get("fill_color")),
|
||
pressure_curve: curve,
|
||
})
|
||
}
|
||
|
||
/// Points along a Bézier curve (without its start), at most every 2 pixels; for a line
|
||
/// just its end.
|
||
fn bezier(start: DVec2, controls: &[DVec2], end: DVec2) -> Vec<DVec2> {
|
||
if controls.is_empty() {
|
||
return vec![end];
|
||
}
|
||
let length = controls
|
||
.iter()
|
||
.chain([&end])
|
||
.fold((0.0, start), |(sum, prev), &p| (sum + prev.distance(p), p))
|
||
.0;
|
||
let steps = ((length / 2.0).ceil() as usize).clamp(1, 32);
|
||
(1..=steps)
|
||
.map(|i| {
|
||
let t = i as f64 / steps as f64;
|
||
let u = 1.0 - t;
|
||
match controls {
|
||
[cp] => start * u * u + *cp * 2.0 * u * t + end * t * t,
|
||
[cp1, cp2] => {
|
||
start * u * u * u
|
||
+ *cp1 * 3.0 * u * u * t
|
||
+ *cp2 * 3.0 * u * t * t
|
||
+ end * t * t * t
|
||
}
|
||
_ => start + (end - start) * t,
|
||
}
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn element(value: &Value) -> Option<(DVec2, f64)> {
|
||
Some((
|
||
vec2(value.get("pos")?)?,
|
||
num(value, "pressure").unwrap_or(0.5),
|
||
))
|
||
}
|
||
|
||
fn brushstroke(value: &Value, highlighter: bool) -> Option<RnoteItem> {
|
||
let style = style(value.get("style"))?;
|
||
let color = style.stroke_color?;
|
||
let path = value.get("path")?;
|
||
let (mut prev, mut prev_pressure) = element(path.get("start")?)?;
|
||
let mut points = vec![prev];
|
||
let mut pressures = vec![prev_pressure];
|
||
for segment in path.get("segments")?.as_array()? {
|
||
let Some((kind, seg)) = variant(segment) else {
|
||
continue;
|
||
};
|
||
let Some((end, end_pressure)) = seg.get("end").and_then(element) else {
|
||
continue;
|
||
};
|
||
let controls: Vec<DVec2> = match kind {
|
||
"quadbezto" | "quadbez" => seg.get("cp").and_then(vec2).into_iter().collect(),
|
||
"cubbezto" | "cubbez" => [seg.get("cp1"), seg.get("cp2")]
|
||
.into_iter()
|
||
.filter_map(|v| v.and_then(vec2))
|
||
.collect(),
|
||
_ => Vec::new(),
|
||
};
|
||
let new = bezier(prev, &controls, end);
|
||
let n = new.len() as f64;
|
||
for (i, p) in new.into_iter().enumerate() {
|
||
let t = (i + 1) as f64 / n;
|
||
points.push(p);
|
||
pressures.push(prev_pressure + (end_pressure - prev_pressure) * t);
|
||
}
|
||
prev = end;
|
||
prev_pressure = end_pressure;
|
||
}
|
||
let widths = pressures
|
||
.iter()
|
||
.map(|&p| curve_width(&style.pressure_curve, style.width, p))
|
||
.collect();
|
||
Some(RnoteItem::Ink {
|
||
highlighter: highlighter || color[3] < 0.99,
|
||
color,
|
||
points,
|
||
widths,
|
||
})
|
||
}
|
||
|
||
/// Outline of a shape as polylines.
|
||
fn shape_lines(shape: &Value) -> Option<Vec<Vec<DVec2>>> {
|
||
let (kind, s) = variant(shape)?;
|
||
let v = |k: &str| s.get(k).and_then(vec2);
|
||
let lines = match kind {
|
||
"line" => vec![vec![v("start")?, v("end")?]],
|
||
"arrow" => {
|
||
let (start, tip) = (v("start")?, v("tip")?);
|
||
let back = (start - tip).normalize_or_zero();
|
||
let length = (start.distance(tip) * 0.4).min(20.0);
|
||
let wing = |angle: f64| tip + DVec2::from_angle(angle).rotate(back) * length;
|
||
vec![vec![start, tip], vec![wing(0.5), tip, wing(-0.5)]]
|
||
}
|
||
"rect" => {
|
||
let half = vec2(s.get("cuboid")?.get("half_extents")?)?;
|
||
let affine = affine(s)?;
|
||
let corners = [
|
||
(-1.0, -1.0),
|
||
(1.0, -1.0),
|
||
(1.0, 1.0),
|
||
(-1.0, 1.0),
|
||
(-1.0, -1.0),
|
||
];
|
||
vec![corners
|
||
.iter()
|
||
.map(|&(x, y)| apply(&affine, DVec2::new(x * half.x, y * half.y)))
|
||
.collect()]
|
||
}
|
||
"ellipse" => {
|
||
let radii = v("radii")?;
|
||
let affine = affine(s)?;
|
||
vec![(0..=64)
|
||
.map(|i| {
|
||
let a = i as f64 / 64.0 * std::f64::consts::TAU;
|
||
apply(&affine, DVec2::new(a.cos() * radii.x, a.sin() * radii.y))
|
||
})
|
||
.collect()]
|
||
}
|
||
"quadbez" | "cubbez" => {
|
||
let start = v("start")?;
|
||
let controls: Vec<DVec2> = ["cp", "cp1", "cp2"].iter().filter_map(|k| v(k)).collect();
|
||
let mut points = vec![start];
|
||
points.extend(bezier(start, &controls, v("end")?));
|
||
vec![points]
|
||
}
|
||
"polyline" | "polygon" => {
|
||
let start = v("start")?;
|
||
let mut points = vec![start];
|
||
points.extend(s.get("path")?.as_array()?.iter().filter_map(vec2));
|
||
if kind == "polygon" {
|
||
points.push(start);
|
||
}
|
||
vec![points]
|
||
}
|
||
_ => return None,
|
||
};
|
||
Some(lines)
|
||
}
|
||
|
||
fn shapestroke(value: &Value, highlighter: bool) -> Vec<RnoteItem> {
|
||
let Some(Style {
|
||
width,
|
||
stroke_color,
|
||
fill_color,
|
||
..
|
||
}) = style(value.get("style"))
|
||
else {
|
||
return vec![RnoteItem::Unsupported];
|
||
};
|
||
let (Some(color), Some(lines)) = (
|
||
stroke_color.or(fill_color),
|
||
value.get("shape").and_then(shape_lines),
|
||
) else {
|
||
return vec![RnoteItem::Unsupported];
|
||
};
|
||
lines
|
||
.into_iter()
|
||
.map(|points| RnoteItem::Ink {
|
||
color,
|
||
highlighter: highlighter || color[3] < 0.99,
|
||
widths: vec![width; points.len()],
|
||
points,
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn textstroke(value: &Value) -> Option<RnoteItem> {
|
||
let style = value.get("text_style")?;
|
||
Some(RnoteItem::Text {
|
||
content: value.get("text")?.as_str()?.to_string(),
|
||
size: num(style, "font_size").unwrap_or(32.0).max(1.0),
|
||
mono: style
|
||
.get("font_family")
|
||
.and_then(Value::as_str)
|
||
.is_some_and(|f| f.to_ascii_lowercase().contains("mono")),
|
||
affine: affine(value)?,
|
||
max_width: num(style, "max_width").filter(|w| *w > 0.0),
|
||
color: color(style.get("color")).unwrap_or([0.0, 0.0, 0.0, 1.0]),
|
||
})
|
||
}
|
||
|
||
fn bitmapimage(value: &Value) -> Option<RnoteItem> {
|
||
let image = value.get("image")?;
|
||
let width = num(image, "pixel_width")? as u32;
|
||
let height = num(image, "pixel_height")? as u32;
|
||
let mut pixels = base64::engine::general_purpose::STANDARD
|
||
.decode(image.get("data")?.as_str()?)
|
||
.ok()?;
|
||
if pixels.len() != width as usize * height as usize * 4 {
|
||
return None;
|
||
}
|
||
import::unpremultiply(&mut pixels);
|
||
Some(RnoteItem::Bitmap {
|
||
width,
|
||
height,
|
||
pixels,
|
||
corners: rectangle_corners(value.get("rectangle")?)?,
|
||
})
|
||
}
|
||
|
||
fn vectorimage(value: &Value) -> Option<RnoteItem> {
|
||
Some(RnoteItem::Svg {
|
||
svg: value.get("svg_data")?.as_str()?.to_string(),
|
||
corners: rectangle_corners(value.get("rectangle")?)?,
|
||
})
|
||
}
|
||
|
||
/// Corners (upper left, upper right, lower right, lower left) of an Rnote rectangle: a
|
||
/// box around the origin, placed by its affine transformation.
|
||
fn rectangle_corners(rectangle: &Value) -> Option<[DVec2; 4]> {
|
||
let half = vec2(rectangle.get("cuboid")?.get("half_extents")?)?;
|
||
let affine = affine(rectangle)?;
|
||
Some(
|
||
[(-1.0, -1.0), (1.0, -1.0), (1.0, 1.0), (-1.0, 1.0)]
|
||
.map(|(x, y)| apply(&affine, DVec2::new(x * half.x, y * half.y))),
|
||
)
|
||
}
|
||
|
||
/// Rnote's version as (major, minor, patch).
|
||
fn version(text: &str) -> Option<(u64, u64, u64)> {
|
||
let v = semver::Version::parse(text).ok()?;
|
||
Some((v.major, v.minor, v.patch))
|
||
}
|
||
|
||
/// Parses the (decompressed) JSON of an .rnote file.
|
||
pub fn parse(json: &[u8]) -> Result<RnoteDocument, String> {
|
||
let not_rnote = || t!("Keine Rnote-Datei").to_string();
|
||
let wrapper: Value = serde_json::from_slice(json).map_err(|_| not_rnote())?;
|
||
let version_text = wrapper
|
||
.get("version")
|
||
.and_then(Value::as_str)
|
||
.ok_or_else(not_rnote)?;
|
||
if version(version_text).is_none_or(|v| v < (0, 5, 10)) {
|
||
return Err(t!(
|
||
"Rnote-Datei zu alt ({version}): bitte in einem aktuellen Rnote öffnen und neu speichern",
|
||
version = version_text
|
||
)
|
||
.to_string());
|
||
}
|
||
let snapshot = wrapper
|
||
.get("data")
|
||
.and_then(|d| d.get("engine_snapshot"))
|
||
.ok_or_else(not_rnote)?;
|
||
let document = snapshot.get("document").ok_or_else(not_rnote)?;
|
||
// Since Rnote 0.13 format, background and layout are in `config`
|
||
let config = document.get("config").unwrap_or(document);
|
||
let format = config.get("format").unwrap_or(&Value::Null);
|
||
let dpi = num(format, "dpi").filter(|d| *d > 0.0).unwrap_or(96.0);
|
||
let format_size = DVec2::new(
|
||
num(format, "width").unwrap_or(dpi * 210.0 / 25.4).max(1.0),
|
||
num(format, "height").unwrap_or(dpi * 297.0 / 25.4).max(1.0),
|
||
);
|
||
let background = match config
|
||
.get("background")
|
||
.and_then(|b| b.get("pattern"))
|
||
.and_then(Value::as_str)
|
||
{
|
||
Some("lines") => PageBackground::Lined,
|
||
Some("grid" | "isometric_grid") => PageBackground::Grid5mm,
|
||
Some("dots" | "isometric_dots") => PageBackground::DotGrid,
|
||
_ => PageBackground::Blank,
|
||
};
|
||
let endless = matches!(
|
||
config.get("layout").and_then(Value::as_str),
|
||
Some("infinite" | "semi_infinite")
|
||
);
|
||
|
||
let strokes = snapshot
|
||
.get("stroke_components")
|
||
.and_then(Value::as_array)
|
||
.ok_or_else(not_rnote)?;
|
||
let chrono = snapshot
|
||
.get("chrono_components")
|
||
.and_then(Value::as_array)
|
||
.map(Vec::as_slice)
|
||
.unwrap_or_default();
|
||
// Slot maps are stored as slot arrays; the chrono components share the slot index
|
||
let mut ordered: Vec<(u64, Vec<RnoteItem>)> = Vec::new();
|
||
for (index, slot) in strokes.iter().enumerate() {
|
||
let Some(stroke) = slot.get("value").filter(|v| !v.is_null()) else {
|
||
continue;
|
||
};
|
||
let chrono = chrono.get(index).and_then(|c| c.get("value"));
|
||
let t = chrono.and_then(|c| c.get("t")).and_then(Value::as_u64);
|
||
let highlighter = chrono
|
||
.and_then(|c| c.get("layer"))
|
||
.and_then(Value::as_str)
|
||
.is_some_and(|l| l.eq_ignore_ascii_case("highlighter"));
|
||
let items = match variant(stroke) {
|
||
Some(("brushstroke", v)) => {
|
||
vec![brushstroke(v, highlighter).unwrap_or(RnoteItem::Unsupported)]
|
||
}
|
||
Some(("shapestroke", v)) => shapestroke(v, highlighter),
|
||
Some(("textstroke", v)) => vec![textstroke(v).unwrap_or(RnoteItem::Unsupported)],
|
||
Some(("bitmapimage", v)) => vec![bitmapimage(v).unwrap_or(RnoteItem::Unsupported)],
|
||
Some(("vectorimage", v)) => vec![vectorimage(v).unwrap_or(RnoteItem::Unsupported)],
|
||
_ => vec![RnoteItem::Unsupported],
|
||
};
|
||
ordered.push((t.unwrap_or(index as u64), items));
|
||
}
|
||
ordered.sort_by_key(|(t, _)| *t);
|
||
|
||
Ok(RnoteDocument {
|
||
format: format_size,
|
||
dpi,
|
||
origin: DVec2::new(
|
||
num(document, "x").unwrap_or(0.0),
|
||
num(document, "y").unwrap_or(0.0),
|
||
),
|
||
size: DVec2::new(
|
||
num(document, "width").unwrap_or(format_size.x),
|
||
num(document, "height").unwrap_or(format_size.y),
|
||
),
|
||
endless,
|
||
background,
|
||
items: ordered.into_iter().flat_map(|(_, items)| items).collect(),
|
||
})
|
||
}
|
||
|
||
/// Creates a new notebook from an Rnote file.
|
||
pub fn create_notebook_from_rnote(
|
||
base_dir: &Path,
|
||
title: &str,
|
||
path: &Path,
|
||
) -> Result<(Notebook, NotebookManifest, std::path::PathBuf, ImportReport), String> {
|
||
let bytes = std::fs::read(path).map_err(|e| e.to_string())?;
|
||
let doc = parse(&import::gunzip(&bytes)?)?;
|
||
import::create_notebook(base_dir, title, |dir| Ok(convert(&doc, dir)))
|
||
}
|
||
|
||
/// A target page: where its Rnote page starts, and how Rnote pixels map onto it.
|
||
struct Target {
|
||
rnote_origin: DVec2,
|
||
origin: glam::Vec2,
|
||
scale: f32,
|
||
size: glam::Vec2,
|
||
strokes: Vec<StrokeData>,
|
||
}
|
||
|
||
impl Target {
|
||
fn map(&self, p: DVec2) -> glam::Vec2 {
|
||
self.origin + (p - self.rnote_origin).as_vec2() * self.scale
|
||
}
|
||
}
|
||
|
||
fn convert(doc: &RnoteDocument, notebook_dir: &Path) -> Imported {
|
||
let assets = crate::assets::AssetStore::new(notebook_dir);
|
||
let mut report = ImportReport::default();
|
||
// Page units per Rnote pixel at the document's dpi
|
||
let units_per_px = (crate::document::UNITS_PER_MM as f64 * 25.4 / doc.dpi) as f32;
|
||
|
||
let (columns, mut targets) = if doc.endless {
|
||
let target = Target {
|
||
rnote_origin: DVec2::ZERO,
|
||
origin: crate::document::ENDLESS_HOME,
|
||
scale: units_per_px,
|
||
size: crate::document::ENDLESS_PAGE_SIZE,
|
||
strokes: Vec::new(),
|
||
};
|
||
(1, vec![target])
|
||
} else {
|
||
// Same rules as for imported PDFs: portrait pages become A4, the content keeps its
|
||
// aspect ratio, centred horizontally and aligned at the top
|
||
let size_pt = (doc.format / doc.dpi * 72.0).as_vec2();
|
||
let size = crate::document::pdf_page_size(size_pt.x, size_pt.y);
|
||
let [origin, top_right, _, bottom_left] =
|
||
crate::document::pdf_placement(size_pt.x, size_pt.y, size);
|
||
let scale_pt =
|
||
((top_right.x - origin.x) / size_pt.x).min((bottom_left.y - origin.y) / size_pt.y);
|
||
let scale = scale_pt * (72.0 / doc.dpi) as f32;
|
||
// Rnote grows documents page by page; tolerate rounding in the stored size
|
||
let count = |length: f64, page: f64| ((length / page - 0.01).ceil() as usize).max(1);
|
||
let columns = count(doc.size.x, doc.format.x);
|
||
let rows = count(doc.size.y, doc.format.y);
|
||
let rows = rows.min((MAX_PAGES / columns).max(1));
|
||
let targets = (0..rows * columns)
|
||
.map(|i| Target {
|
||
rnote_origin: doc.origin
|
||
+ DVec2::new((i % columns) as f64, (i / columns) as f64) * doc.format,
|
||
origin,
|
||
scale,
|
||
size,
|
||
strokes: Vec::new(),
|
||
})
|
||
.collect();
|
||
(columns, targets)
|
||
};
|
||
let rows = targets.len() / columns;
|
||
|
||
let mut next_id: u64 = 1;
|
||
for item in &doc.items {
|
||
let Some(anchor) = item.anchor() else {
|
||
report.skipped += 1;
|
||
continue;
|
||
};
|
||
let cell = ((anchor - doc.origin) / doc.format).floor();
|
||
let index = if doc.endless {
|
||
0
|
||
} else {
|
||
let column = (cell.x.max(0.0) as usize).min(columns - 1);
|
||
let row = (cell.y.max(0.0) as usize).min(rows - 1);
|
||
row * columns + column
|
||
};
|
||
let target = &mut targets[index];
|
||
let id = next_id;
|
||
next_id += 1;
|
||
let stroke = match item {
|
||
RnoteItem::Ink {
|
||
color,
|
||
highlighter,
|
||
points,
|
||
widths,
|
||
} => {
|
||
let points: Vec<glam::Vec2> = points.iter().map(|&p| target.map(p)).collect();
|
||
let widths: Vec<f32> = widths.iter().map(|&w| w as f32 * target.scale).collect();
|
||
let (width, pressures) = import::fit_widths(&widths);
|
||
import::ink_stroke(id, *color, *highlighter, &points, width, &pressures)
|
||
}
|
||
RnoteItem::Text {
|
||
content,
|
||
size,
|
||
mono,
|
||
affine,
|
||
max_width,
|
||
color,
|
||
} => {
|
||
let font = if *mono {
|
||
TextFont::Mono
|
||
} else {
|
||
TextFont::Sans
|
||
};
|
||
import::text_stroke(
|
||
id,
|
||
content,
|
||
*size as f32 * target.scale,
|
||
font,
|
||
target.map(affine[2]),
|
||
[affine[0].as_vec2(), affine[1].as_vec2()],
|
||
max_width.map(|w| w as f32 * target.scale),
|
||
*color,
|
||
)
|
||
}
|
||
RnoteItem::Bitmap {
|
||
width,
|
||
height,
|
||
pixels,
|
||
corners,
|
||
} => match assets.import_rgba(*width, *height, pixels.clone()) {
|
||
Ok(image) => import::image_stroke(id, image.asset, corners.map(|c| target.map(c))),
|
||
Err(_) => {
|
||
report.skipped += 1;
|
||
continue;
|
||
}
|
||
},
|
||
RnoteItem::Svg { svg, corners } => {
|
||
let corners = corners.map(|c| target.map(c));
|
||
let size = glam::Vec2::new(
|
||
corners[0].distance(corners[1]),
|
||
corners[0].distance(corners[3]),
|
||
);
|
||
let image = import::rasterize_svg(svg, size).and_then(|(width, height, pixels)| {
|
||
assets.import_rgba(width, height, pixels).ok()
|
||
});
|
||
match image {
|
||
Some(image) => import::image_stroke(id, image.asset, corners),
|
||
None => {
|
||
report.skipped += 1;
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
RnoteItem::Unsupported => unreachable!("has no anchor"),
|
||
};
|
||
target.strokes.push(stroke);
|
||
}
|
||
|
||
let pages = targets
|
||
.into_iter()
|
||
.enumerate()
|
||
.map(|(i, target)| {
|
||
import::page(
|
||
i as u64 + 1,
|
||
target.size,
|
||
doc.background,
|
||
None,
|
||
target.strokes,
|
||
)
|
||
})
|
||
.collect();
|
||
Imported {
|
||
pages,
|
||
next_stroke_id: next_id,
|
||
layout: doc.endless.then_some(NotebookLayout::Endless),
|
||
report,
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
use crate::document::StrokeTool;
|
||
use serde_json::json;
|
||
use std::io::Write;
|
||
|
||
fn slot(value: Value) -> Value {
|
||
json!({ "value": value, "version": 1 })
|
||
}
|
||
|
||
/// A small Rnote 0.15 document: two A4 pages at 96 dpi.
|
||
fn sample(layout: &str) -> Value {
|
||
let brush = json!({ "brushstroke": {
|
||
"path": {
|
||
"start": { "pos": [100.0, 100.0], "pressure": 0.5 },
|
||
"segments": [
|
||
{ "lineto": { "end": { "pos": [120.0, 100.0], "pressure": 1.0 } } },
|
||
{ "cubbezto": { "cp1": [130.0, 110.0], "cp2": [140.0, 110.0],
|
||
"end": { "pos": [150.0, 100.0], "pressure": 0.25 } } }
|
||
]
|
||
},
|
||
"style": { "smooth": { "stroke_width": 4.0,
|
||
"stroke_color": { "r": 0.0, "g": 0.0, "b": 1.0, "a": 1.0 },
|
||
"fill_color": null, "pressure_curve": "linear" } }
|
||
}});
|
||
let rect = json!({ "shapestroke": {
|
||
"shape": { "rect": { "cuboid": { "half_extents": [50.0, 20.0] },
|
||
"affine": [1.0, 0.0, 0.0, 1.0, 300.0, 1300.0] } },
|
||
"style": { "rough": { "stroke_width": 2.0,
|
||
"stroke_color": { "r": 1.0, "g": 0.0, "b": 0.0, "a": 1.0 } } }
|
||
}});
|
||
let text = json!({ "textstroke": {
|
||
"text": "Hallo",
|
||
"affine": [1.0, 0.0, 0.0, 1.0, 50.0, 60.0],
|
||
"text_style": { "font_family": "serif", "font_size": 32.0, "max_width": null,
|
||
"color": { "r": 0.0, "g": 0.0, "b": 0.0, "a": 1.0 } }
|
||
}});
|
||
let pixels = base64::engine::general_purpose::STANDARD.encode([128u8, 0, 0, 128].repeat(4));
|
||
let bitmap = json!({ "bitmapimage": {
|
||
"image": { "data": pixels, "pixel_width": 2, "pixel_height": 2,
|
||
"memory_format": "R8g8b8a8Premultiplied" },
|
||
"rectangle": { "cuboid": { "half_extents": [10.0, 10.0] },
|
||
"affine": [1.0, 0.0, 0.0, 1.0, 400.0, 400.0] }
|
||
}});
|
||
let svg = json!({ "vectorimage": {
|
||
"svg_data": "<svg xmlns='http://www.w3.org/2000/svg' width='10' height='10'><rect width='10' height='10' fill='green'/></svg>",
|
||
"intrinsic_size": [10.0, 10.0],
|
||
"rectangle": { "cuboid": { "half_extents": [40.0, 40.0] },
|
||
"affine": [1.0, 0.0, 0.0, 1.0, 400.0, 1500.0] }
|
||
}});
|
||
let marker = json!({ "brushstroke": {
|
||
"path": { "start": { "pos": [10.0, 10.0], "pressure": 1.0 },
|
||
"segments": [ { "lineto": { "end": { "pos": [90.0, 10.0], "pressure": 1.0 } } } ] },
|
||
"style": { "smooth": { "stroke_width": 12.0,
|
||
"stroke_color": { "r": 1.0, "g": 1.0, "b": 0.0, "a": 1.0 },
|
||
"fill_color": null, "pressure_curve": "const" } }
|
||
}});
|
||
let chrono = |t: u32, layer: &str| slot(json!({ "t": t, "layer": layer }));
|
||
json!({
|
||
"version": "0.15.0",
|
||
"data": { "engine_snapshot": {
|
||
"document": {
|
||
"config": {
|
||
"format": { "width": 793.701, "height": 1122.52, "dpi": 96.0 },
|
||
"background": { "pattern": "grid" },
|
||
"layout": layout
|
||
},
|
||
"x": 0.0, "y": 0.0, "width": 793.701, "height": 2245.04
|
||
},
|
||
"camera": {},
|
||
// Slot 0 is the slot map's unused sentinel; the text was drawn first
|
||
"stroke_components": [
|
||
{ "value": null, "version": 0 },
|
||
slot(brush), slot(rect), slot(text), slot(bitmap), slot(svg), slot(marker)
|
||
],
|
||
"chrono_components": [
|
||
{ "value": null, "version": 0 },
|
||
chrono(2, "user_layer"), chrono(3, "user_layer"), chrono(1, "user_layer"),
|
||
chrono(4, "image"), chrono(5, "image"), chrono(6, "highlighter")
|
||
],
|
||
"chrono_counter": 7
|
||
}}
|
||
})
|
||
}
|
||
|
||
fn write_rnote(dir: &Path, value: &Value) -> std::path::PathBuf {
|
||
let path = dir.join("Skizze.rnote");
|
||
let mut encoder = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
|
||
encoder.write_all(value.to_string().as_bytes()).unwrap();
|
||
std::fs::write(&path, encoder.finish().unwrap()).unwrap();
|
||
path
|
||
}
|
||
|
||
#[test]
|
||
fn test_parse_rnote() {
|
||
let doc = parse(sample("fixed_size").to_string().as_bytes()).unwrap();
|
||
assert_eq!(doc.background, PageBackground::Grid5mm);
|
||
assert!(!doc.endless);
|
||
// In drawing order: the text was drawn first
|
||
assert!(matches!(doc.items[0], RnoteItem::Text { .. }));
|
||
match &doc.items[1] {
|
||
RnoteItem::Ink {
|
||
points,
|
||
widths,
|
||
color,
|
||
highlighter,
|
||
} => {
|
||
assert!(!highlighter);
|
||
assert_eq!(*color, [0.0, 0.0, 1.0, 1.0]);
|
||
assert_eq!(points.first(), Some(&DVec2::new(100.0, 100.0)));
|
||
assert_eq!(points.last(), Some(&DVec2::new(150.0, 100.0)));
|
||
assert!(points.len() > 3, "the curve is sampled");
|
||
assert_eq!(widths[0], 2.0);
|
||
assert_eq!(widths[1], 4.0);
|
||
assert_eq!(*widths.last().unwrap(), 1.0);
|
||
}
|
||
other => panic!("expected ink, got {other:?}"),
|
||
}
|
||
match &doc.items[2] {
|
||
RnoteItem::Ink { points, .. } => {
|
||
assert_eq!(points.len(), 5);
|
||
assert_eq!(points[0], DVec2::new(250.0, 1280.0));
|
||
assert_eq!(points[2], DVec2::new(350.0, 1320.0));
|
||
}
|
||
other => panic!("expected the rectangle, got {other:?}"),
|
||
}
|
||
match &doc.items[3] {
|
||
RnoteItem::Bitmap { pixels, .. } => assert_eq!(&pixels[..4], &[255, 0, 0, 128]),
|
||
other => panic!("expected a bitmap, got {other:?}"),
|
||
}
|
||
assert!(matches!(doc.items[4], RnoteItem::Svg { .. }));
|
||
assert!(matches!(
|
||
doc.items[5],
|
||
RnoteItem::Ink {
|
||
highlighter: true,
|
||
..
|
||
}
|
||
));
|
||
}
|
||
|
||
#[test]
|
||
fn test_older_formats() {
|
||
// Before 0.13: format, background and layout directly in the document; before 0.15:
|
||
// transformations as column-major 3×3 matrix
|
||
let mut value = sample("continuous_vertical");
|
||
value["version"] = json!("0.9.4");
|
||
let document = &mut value["data"]["engine_snapshot"]["document"];
|
||
let config = document["config"].take();
|
||
for key in ["format", "background", "layout"] {
|
||
document[key] = config[key].clone();
|
||
}
|
||
document.as_object_mut().unwrap().remove("config");
|
||
let text =
|
||
&mut value["data"]["engine_snapshot"]["stroke_components"][3]["value"]["textstroke"];
|
||
text.as_object_mut().unwrap().remove("affine");
|
||
text["transform"] = json!({ "affine": [1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 50.0, 60.0, 1.0] });
|
||
let doc = parse(value.to_string().as_bytes()).unwrap();
|
||
assert_eq!(doc.background, PageBackground::Grid5mm);
|
||
match &doc.items[0] {
|
||
RnoteItem::Text { affine, .. } => assert_eq!(affine[2], DVec2::new(50.0, 60.0)),
|
||
other => panic!("expected a text, got {other:?}"),
|
||
}
|
||
|
||
value["version"] = json!("0.5.5");
|
||
assert!(parse(value.to_string().as_bytes()).is_err());
|
||
assert!(parse(b"{\"a\": 1}").is_err());
|
||
}
|
||
|
||
#[test]
|
||
fn test_create_notebook_from_rnote() {
|
||
let temp_dir = tempfile::tempdir().unwrap();
|
||
let source_dir = tempfile::tempdir().unwrap();
|
||
let path = write_rnote(source_dir.path(), &sample("fixed_size"));
|
||
let (notebook, manifest, dir, report) =
|
||
create_notebook_from_rnote(temp_dir.path(), "Skizze", &path).unwrap();
|
||
assert_eq!(report, ImportReport::default());
|
||
assert_eq!(manifest.layout, NotebookManifest::new("x", "x").layout);
|
||
|
||
let (mut reloaded, _) = crate::storage::load_notebook(&dir).unwrap();
|
||
crate::storage::load_all_pages(&dir, &mut reloaded).unwrap();
|
||
assert_eq!(notebook.pages.len(), 2);
|
||
let [first, second] = &reloaded.pages[..] else {
|
||
panic!("two pages expected");
|
||
};
|
||
assert_eq!(first.background, PageBackground::Grid5mm);
|
||
// Text, pen, bitmap, highlighter on page 1; rectangle and SVG on page 2
|
||
assert_eq!(first.strokes.len(), 4);
|
||
assert_eq!(second.strokes.len(), 2);
|
||
assert!(first.strokes[0].is_text());
|
||
let pen = &first.strokes[1];
|
||
assert_eq!(pen.tool, StrokeTool::Pen);
|
||
// 96 dpi: 100 px = 26.46 mm
|
||
assert!((pen.points[0].position.x - 264.6).abs() < 0.5);
|
||
assert!(first.strokes[2].is_image());
|
||
assert_eq!(first.strokes[3].tool, StrokeTool::Highlighter);
|
||
// The rectangle sits on page 2 in page coordinates: 250 px - 0 / 1280 px - 1122.52 px
|
||
let rect = &second.strokes[0];
|
||
assert!((rect.points[0].position.x - 661.5).abs() < 0.5);
|
||
assert!((rect.points[0].position.y - 416.7).abs() < 0.5);
|
||
assert!(second.strokes[1].is_image());
|
||
}
|
||
|
||
#[test]
|
||
fn test_infinite_documents_become_endless() {
|
||
let temp_dir = tempfile::tempdir().unwrap();
|
||
let source_dir = tempfile::tempdir().unwrap();
|
||
let path = write_rnote(source_dir.path(), &sample("infinite"));
|
||
let (notebook, manifest, _, _) =
|
||
create_notebook_from_rnote(temp_dir.path(), "Skizze", &path).unwrap();
|
||
assert_eq!(manifest.layout, Some(NotebookLayout::Endless));
|
||
assert_eq!(notebook.pages.len(), 1);
|
||
assert!(notebook.pages[0].is_endless());
|
||
assert_eq!(notebook.pages[0].strokes.len(), 6);
|
||
let pen = ¬ebook.pages[0].strokes[1];
|
||
let home = crate::document::ENDLESS_HOME;
|
||
assert!((pen.points[0].position.x - home.x - 264.6).abs() < 0.5);
|
||
}
|
||
}
|