LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
LRC-PRINT-IMAGESETTINGS: compose print pages (fit / Zoom to Fill, Rotate to Fit, border, stroke, background)
Atmik Shetty8336f06d283c
diff --git a/crates/engine/src/contact_sheet.rs b/crates/engine/src/contact_sheet.rsindex e83ad8c67..af4228e67 100644--- a/crates/engine/src/contact_sheet.rs+++ b/crates/engine/src/contact_sheet.rs@@ -197,14 +197,14 @@ fn blit(dst: &mut Rgba8, src: &Rgba8, x: usize, y: usize) -> Result<(), String>}// Minimal PDF 1.4: one JPEG XObject per page, explicit byte lengths and classic xref offsets.-struct Pdf {- bytes: Vec<u8>,+pub(crate) struct Pdf {+ pub(crate) bytes: Vec<u8>,offsets: Vec<usize>,points: (f64, f64),}impl Pdf {- fn new(pages: usize, points: (f64, f64)) -> Self {+ pub(crate) fn new(pages: usize, points: (f64, f64)) -> Self {let mut p = Self { bytes: b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n".to_vec(), offsets: vec![0], points };p.object(1, b"<< /Type /Catalog /Pages 2 0 R >>");let kids = (0..pages).map(|i| format!("{} 0 R", 3 + i * 3)).collect::<Vec<_>>().join(" ");@@ -226,7 +226,7 @@ impl Pdf {self.object(id, &body);}- fn page(&mut self, index: usize, jpg: &[u8], width: usize, height: usize) {+ pub(crate) fn page(&mut self, index: usize, jpg: &[u8], width: usize, height: usize) {let id = 3 + index * 3;let (w, h) = self.points;self.object(@@ -246,7 +246,7 @@ impl Pdf {);}- fn finish(mut self) -> Vec<u8> {+ pub(crate) fn finish(mut self) -> Vec<u8> {let start = self.bytes.len();self.bytes.extend_from_slice(format!("xref\n0 {}\n0000000000 65535 f \n", self.offsets.len()).as_bytes());for offset in self.offsets.iter().skip(1) {diff --git a/crates/engine/src/print/compose.rs b/crates/engine/src/print/compose.rsnew file mode 100644index 000000000..58b29b0d9--- /dev/null+++ b/crates/engine/src/print/compose.rs@@ -0,0 +1,845 @@+//! Composes print pages: places each cell's photo (fit or Zoom to Fill, optionally Rotate to Fit),+//! draws Photo Border and Inner Stroke, fills the page background and returns [`PageRaster`]s.+//!+//! Work is split like an export: [`prepare`] reads the session (which photos go in which cell, one+//! render job per cell) and [`Prepared::run`] does the heavy part without it, so it can run on a+//! background thread with progress and cancellation.+//!+//! Photos are rendered with the normal export pipeline into Rec. 2020 at 16 bits, at exactly the+//! pixel size the cell needs at the job's resolution; colours given in sRGB (background, border,+//! stroke) are converted to the same encoding.+use super::layout::{Layout, Rect, Style};+use super::template::PrintSettings;+use super::{MAX_JOB_PAGES, MAX_JOB_PIXELS, MAX_PAGE_PIXELS, PageRaster};+use crate::Session;+use crate::export::{ExportOptions, output_size};+use crate::media::RenderJob;+use lightcraft_catalog::PhotoId;+use lightcraft_color::transfer::srgb_to_linear;+use lightcraft_color::{REC2020, SRGB};+use lightcraft_pipeline::{DeepSamples, OutputDepth, OutputSpace};+use serde::{Deserialize, Serialize};++/// Most photos one print job takes.+pub const MAX_PHOTOS: usize = 1000;+/// Widest Photo Border, inches.+pub const MAX_BORDER_IN: f64 = 2.0;+/// Widest Inner Stroke, points.+pub const MAX_STROKE_PT: f64 = 36.0;+/// Renders kept for cells that print the same photo at the same size.+const RENDER_CACHE: usize = 4;++/// Lightroom's Image Settings panel.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(default, rename_all = "camelCase", deny_unknown_fields)]+pub struct ImageSettings {+ /// Fill each cell with the photo and crop what overflows (centred); off: fit the whole photo.+ pub zoom_to_fill: bool,+ /// Turn a photo a quarter when that makes it print larger (fit) or crop less (fill).+ pub rotate_to_fit: bool,+ /// A border around the photo inside its cell; Picture Package and Custom Package only.+ pub border_enabled: bool,+ /// Border width, inches.+ pub border_width: f64,+ /// Border colour, sRGB.+ pub border_color: [u8; 3],+ /// A stroke drawn inside the photo's edge, every layout style.+ pub stroke_enabled: bool,+ /// Stroke width, points.+ pub stroke_width_pt: f64,+ /// Stroke colour, sRGB.+ pub stroke_color: [u8; 3],+}++impl Default for ImageSettings {+ fn default() -> Self {+ Self {+ zoom_to_fill: false,+ rotate_to_fit: false,+ border_enabled: false,+ border_width: 0.25,+ border_color: [255; 3],+ stroke_enabled: false,+ stroke_width_pt: 1.0,+ stroke_color: [0; 3],+ }+ }+}++impl ImageSettings {+ pub fn validate(&self) -> Result<(), String> {+ let ok = |v: f64, max: f64| v.is_finite() && (0.0..=max).contains(&v);+ if !ok(self.border_width, MAX_BORDER_IN) {+ return Err(format!("border width must be 0 to {MAX_BORDER_IN} in"));+ }+ if !ok(self.stroke_width_pt, MAX_STROKE_PT) {+ return Err(format!("stroke width must be 0 to {MAX_STROKE_PT} pt"));+ }+ Ok(())+ }+}++/// Lightroom's Page panel (the parts that are not margins or overlays).+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(default, rename_all = "camelCase", deny_unknown_fields)]+pub struct PageStyle {+ /// Page background colour, sRGB.+ pub background: [u8; 3],+}++impl Default for PageStyle {+ fn default() -> Self {+ Self { background: [255; 3] }+ }+}++/// An sRGB colour as 16-bit Rec. 2020 samples (the encoding of [`PageRaster`]).+pub fn rec2020_from_srgb8(c: [u8; 3]) -> [u16; 3] {+ let lin = SRGB.to_space(&REC2020).apply_f32(c.map(|v| srgb_to_linear(f32::from(v) / 255.0)));+ let trc = OutputSpace::Rec2020.trc();+ lin.map(|v| (trc.encode(v) * 65535.0 + 0.5) as u16)+}++// ---- placement ------------------------------------------------------------------------------++/// How a photo of `iw` x `ih` goes into an `aw` x `ah` area.+#[derive(Clone, Copy, Debug, PartialEq)]+pub struct Placement {+ /// Turned a quarter (clockwise).+ pub rotated: bool,+ /// Scaled size after turning: at most the area when fitting, at least the area when filling.+ pub w: usize,+ pub h: usize,+}++impl Placement {+ /// The scaled size before turning (the size to render at).+ pub fn unturned(&self) -> (usize, usize) {+ if self.rotated { (self.h, self.w) } else { (self.w, self.h) }+ }+}++/// Decides turning and scale. `None` for an empty area or a photo without size.+pub fn place(iw: f64, ih: f64, aw: usize, ah: usize, fill: bool, rotate: bool) -> Option<Placement> {+ if !(iw.is_finite() && ih.is_finite() && iw >= 1.0 && ih >= 1.0) || aw == 0 || ah == 0 {+ return None;+ }+ let (af, bf) = (aw as f64, ah as f64);+ let scale = |w: f64, h: f64| if fill { (af / w).max(bf / h) } else { (af / w).min(bf / h) };+ let (s0, s1) = (scale(iw, ih), scale(ih, iw));+ let rotated = rotate && if fill { s1 < s0 * (1.0 - 1e-9) } else { s1 > s0 * (1.0 + 1e-9) };+ let (w, h) = if rotated { (ih * s1, iw * s1) } else { (iw * s0, ih * s0) };+ let (w, h) = if fill {+ (((w - 1e-6).ceil() as usize).max(aw), ((h - 1e-6).ceil() as usize).max(ah))+ } else {+ ((w.round() as usize).clamp(1, aw), (h.round() as usize).clamp(1, ah))+ };+ Some(Placement { rotated, w, h })+}++/// A rectangle in page pixels.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub struct PxRect {+ pub x: usize,+ pub y: usize,+ pub w: usize,+ pub h: usize,+}++/// The pixel rectangle of an inch rectangle on a `pw` x `ph` page at `ppi`, clipped to the page.+pub fn px_rect(r: &Rect, ppi: f64, pw: usize, ph: usize) -> Option<PxRect> {+ if !r.is_finite() {+ return None;+ }+ let edge = |v: f64, max: usize| (v * ppi).round().clamp(0.0, max as f64) as usize;+ let (x0, y0, x1, y1) = (edge(r.x, pw), edge(r.y, ph), edge(r.right(), pw), edge(r.bottom(), ph));+ (x1 > x0 && y1 > y0).then_some(PxRect { x: x0, y: y0, w: x1 - x0, h: y1 - y0 })+}++/// The cells of every page with the photo each prints, by layout style: Single Image and Contact+/// Sheet lay `photos` out in sequence over as many pages as needed; Picture Package prints the+/// first photo in every cell; Custom Package prints each cell's own photo (else the first).+pub fn plan_cells(layout: &Layout, photos: &[PhotoId]) -> Result<Vec<Vec<(Rect, PhotoId)>>, String> {+ let first = photos.first().copied().ok_or("select at least one photo to print")?;+ if photos.len() > MAX_PHOTOS {+ return Err(format!("a print takes at most {MAX_PHOTOS} photos"));+ }+ match layout.style {+ Style::SingleImage | Style::ContactSheet => {+ let grid = layout.grid_rects()?;+ let per_page = grid.len().max(1);+ let pages = photos.len().div_ceil(per_page);+ if pages > MAX_JOB_PAGES {+ return Err(format!("a print is limited to {MAX_JOB_PAGES} pages; use a bigger grid or fewer photos"));+ }+ Ok(photos.chunks(per_page).map(|chunk| chunk.iter().zip(&grid).map(|(id, r)| (*r, *id)).collect()).collect())+ }+ Style::PicturePackage | Style::CustomPackage => {+ let pages = layout.pages.max(1) as usize;+ if pages > MAX_JOB_PAGES {+ return Err(format!("a print is limited to {MAX_JOB_PAGES} pages"));+ }+ if layout.cells.is_empty() {+ return Err("the layout has no cells; add some (print.cell.add) or use Auto Layout".into());+ }+ let mut out: Vec<Vec<(Rect, PhotoId)>> = vec![Vec::new(); pages];+ for c in &layout.cells {+ let photo = match layout.style {+ Style::CustomPackage => c.photo.map_or(first, PhotoId),+ _ => first,+ };+ out.get_mut(c.page as usize).ok_or("a cell is on a page the layout does not have")?.push((c.rect, photo));+ }+ Ok(out)+ }+ }+}++// ---- pixels ----------------------------------------------------------------------------------++/// 16-bit interleaved RGB.+#[derive(Clone, Debug, PartialEq)]+pub struct Image16 {+ pub w: usize,+ pub h: usize,+ pub rgb: Vec<u16>,+}++impl Image16 {+ pub fn filled(w: usize, h: usize, c: [u16; 3]) -> Result<Self, String> {+ let n = w.checked_mul(h).and_then(|n| n.checked_mul(3)).ok_or("image too large")?;+ let mut rgb = Vec::new();+ rgb.try_reserve_exact(n).map_err(|_| "not enough memory for the page")?;+ for _ in 0..w * h {+ rgb.extend_from_slice(&c);+ }+ Ok(Self { w, h, rgb })+ }++ fn px(&self, x: usize, y: usize) -> Option<[u16; 3]> {+ let i = y.checked_mul(self.w)?.checked_add(x)?.checked_mul(3)?;+ let s = self.rgb.get(i..i.checked_add(3)?)?;+ Some([*s.first()?, *s.get(1)?, *s.get(2)?])+ }++ /// Fills a rectangle (clipped to the image).+ pub fn fill_rect(&mut self, x: usize, y: usize, w: usize, h: usize, c: [u16; 3]) {+ let x1 = x.saturating_add(w).min(self.w);+ for row in y..y.saturating_add(h).min(self.h) {+ let Some(line) = self.rgb.get_mut((row * self.w + x.min(x1)) * 3..(row * self.w + x1) * 3) else { continue };+ for px in line.as_chunks_mut::<3>().0 {+ *px = c;+ }+ }+ }++ /// Copies the `w` x `h` block of `src` at (`sx`, `sy`) to (`dx`, `dy`), clipped to both images.+ pub fn blit(&mut self, src: &Image16, sx: usize, sy: usize, dx: usize, dy: usize, w: usize, h: usize) {+ let w = w.min(src.w.saturating_sub(sx)).min(self.w.saturating_sub(dx));+ let h = h.min(src.h.saturating_sub(sy)).min(self.h.saturating_sub(dy));+ for row in 0..h {+ let from = src.rgb.get(((sy + row) * src.w + sx) * 3..((sy + row) * src.w + sx + w) * 3);+ let to = self.rgb.get_mut(((dy + row) * self.w + dx) * 3..((dy + row) * self.w + dx + w) * 3);+ if let (Some(from), Some(to)) = (from, to) {+ to.copy_from_slice(from);+ }+ }+ }++ /// A quarter turn clockwise.+ pub fn rotated_cw(&self) -> Result<Image16, String> {+ let mut out = Image16::filled(self.h, self.w, [0; 3])?;+ for y in 0..self.h {+ for x in 0..self.w {+ let Some(p) = self.px(x, y) else { continue };+ // (x, y) lands at (h - 1 - y, x).+ let i = (x * out.w + (self.h - 1 - y)) * 3;+ if let Some(d) = out.rgb.get_mut(i..i + 3) {+ d.copy_from_slice(&p);+ }+ }+ }+ Ok(out)+ }++ /// Scales to `nw` x `nh`: area-weighted when shrinking an axis, linear when growing it.+ pub fn resized(&self, nw: usize, nh: usize) -> Result<Image16, String> {+ if nw == 0 || nh == 0 || self.w == 0 || self.h == 0 {+ return Err("empty image".into());+ }+ if (nw, nh) == (self.w, self.h) {+ return Ok(self.clone());+ }+ let wx = axis_weights(self.w, nw);+ let wy = axis_weights(self.h, nh);+ // Horizontal pass into 16-bit rows, then the vertical pass.+ let mut mid = Image16::filled(nw, self.h, [0; 3])?;+ for y in 0..self.h {+ let Some(src) = self.rgb.get(y * self.w * 3..(y + 1) * self.w * 3) else { continue };+ let Some(dst) = mid.rgb.get_mut(y * nw * 3..(y + 1) * nw * 3) else { continue };+ for (x, taps) in wx.iter().enumerate() {+ for c in 0..3 {+ let v: f32 = taps.iter().map(|&(i, k)| src.get(i * 3 + c).map_or(0.0, |s| f32::from(*s) * k)).sum();+ if let Some(d) = dst.get_mut(x * 3 + c) {+ *d = v.round().clamp(0.0, 65535.0) as u16;+ }+ }+ }+ }+ let mut out = Image16::filled(nw, nh, [0; 3])?;+ for (y, taps) in wy.iter().enumerate() {+ let Some(dst) = out.rgb.get_mut(y * nw * 3..(y + 1) * nw * 3) else { continue };+ for (i, d) in dst.iter_mut().enumerate() {+ let v: f32 = taps.iter().map(|&(row, k)| mid.rgb.get(row * nw * 3 + i).map_or(0.0, |s| f32::from(*s) * k)).sum();+ *d = v.round().clamp(0.0, 65535.0) as u16;+ }+ }+ Ok(out)+ }+}++/// For each of `new` output samples, the `(source index, weight)` taps that make it (weights sum to 1).+fn axis_weights(old: usize, new: usize) -> Vec<Vec<(usize, f32)>> {+ let (o, n) = (old as f64, new as f64);+ (0..new)+ .map(|i| {+ if new < old {+ let step = o / n;+ let (a, b) = (i as f64 * step, (i as f64 + 1.0) * step);+ let first = a.floor() as usize;+ let last = (b.ceil() as usize).min(old);+ (first..last)+ .filter_map(|j| {+ let overlap = (b.min(j as f64 + 1.0) - a.max(j as f64)).max(0.0);+ (overlap > 0.0).then_some((j, (overlap / step) as f32))+ })+ .collect()+ } else {+ let pos = (i as f64 + 0.5) * o / n - 0.5;+ let j0 = pos.floor();+ let f = (pos - j0) as f32;+ let at = |j: f64| j.clamp(0.0, o - 1.0) as usize;+ vec![(at(j0), 1.0 - f), (at(j0 + 1.0), f)]+ }+ })+ .collect()+}++/// Everything about a cell's look that does not depend on the photo.+#[derive(Clone, Copy, Debug, PartialEq)]+pub struct CellStyle {+ pub fill: bool,+ pub rotate: bool,+ pub border_px: usize,+ pub border: [u16; 3],+ pub stroke_px: usize,+ pub stroke: [u16; 3],+}++impl CellStyle {+ /// The style for `settings` at `ppi`; the border applies to the package styles only.+ pub fn of(settings: &PrintSettings, ppi: f64) -> Self {+ let img = &settings.image;+ let border_px = if img.border_enabled && settings.layout.style.is_package() { (img.border_width * ppi).round() as usize } else { 0 };+ let stroke_px =+ if img.stroke_enabled && img.stroke_width_pt > 0.0 { ((img.stroke_width_pt / 72.0 * ppi).round() as usize).max(1) } else { 0 };+ Self {+ fill: img.zoom_to_fill,+ rotate: img.rotate_to_fit,+ border_px,+ border: rec2020_from_srgb8(img.border_color),+ stroke_px,+ stroke: rec2020_from_srgb8(img.stroke_color),+ }+ }+}++/// Draws `photo` into `cell` of `page`: border frame, the photo fitted or filled (and turned when+/// asked), then the inner stroke on top of it.+pub fn draw_cell(page: &mut Image16, photo: &Image16, cell: PxRect, style: &CellStyle) -> Result<(), String> {+ // The border may not eat the cell: at least one pixel of photo area stays.+ let border = style.border_px.min(cell.w.min(cell.h).saturating_sub(1) / 2);+ let (ax, ay) = (cell.x + border, cell.y + border);+ let (aw, ah) = (cell.w - 2 * border, cell.h - 2 * border);+ let p = place(photo.w as f64, photo.h as f64, aw, ah, style.fill, style.rotate).ok_or("a photo has no size")?;+ let (uw, uh) = p.unturned();+ let mut img = photo.resized(uw, uh)?;+ if p.rotated {+ img = img.rotated_cw()?;+ }+ // Where the photo lands: centred in the area, cropped to it when it overflows.+ let (sx, sy) = (img.w.saturating_sub(aw) / 2, img.h.saturating_sub(ah) / 2);+ let (w, h) = (img.w.min(aw), img.h.min(ah));+ let (dx, dy) = (ax + (aw - w) / 2, ay + (ah - h) / 2);+ if border > 0 {+ page.fill_rect(dx - border, dy - border, w + 2 * border, h + 2 * border, style.border);+ }+ page.blit(&img, sx, sy, dx, dy, w, h);+ let s = style.stroke_px.min(w.min(h) / 2);+ if s > 0 {+ page.fill_rect(dx, dy, w, s, style.stroke);+ page.fill_rect(dx, dy + h - s, w, s, style.stroke);+ page.fill_rect(dx, dy + s, s, h - 2 * s, style.stroke);+ page.fill_rect(dx + w - s, dy + s, s, h - 2 * s, style.stroke);+ }+ Ok(())+}++// ---- the job ---------------------------------------------------------------------------------++struct Item {+ page: usize,+ name: String,+ cell: PxRect,+ key: (u64, usize, usize),+ job: RenderJob,+}++/// A print job set up from the session: one render per cell, ready to run on another thread.+pub struct Prepared {+ pages: Vec<(usize, usize)>,+ items: Vec<Item>,+ ppi: f32,+ background: [u16; 3],+ style: CellStyle,+}++impl Prepared {+ /// Renders (progress steps) the job will run.+ pub fn len(&self) -> usize {+ self.items.len()+ }++ pub fn is_empty(&self) -> bool {+ self.items.is_empty()+ }++ /// Pages the job will produce.+ pub fn pages(&self) -> usize {+ self.pages.len()+ }++ /// Renders every photo and composes the pages. `progress(done, name)` is called before each+ /// render with the photo's file name; returning `false` cancels (no partial result).+ pub fn run(self, progress: &mut dyn FnMut(usize, &str) -> bool) -> Result<Vec<PageRaster>, String> {+ let mut cache: Vec<((u64, usize, usize), Image16)> = Vec::new();+ let mut done = 0usize;+ let mut items = self.items.into_iter().peekable();+ let mut out = Vec::with_capacity(self.pages.len());+ for (index, &(w, h)) in self.pages.iter().enumerate() {+ let mut page = Image16::filled(w, h, self.background)?;+ while let Some(item) = items.next_if(|i| i.page == index) {+ if !progress(done, &item.name) {+ return Err("Print cancelled".into());+ }+ done += 1;+ let at = cache.iter().position(|(k, _)| *k == item.key);+ let at = match at {+ Some(at) => at,+ None => {+ let img = render(item.job).map_err(|e| format!("{}: {e}", item.name))?;+ if cache.len() >= RENDER_CACHE {+ cache.remove(0);+ }+ cache.push((item.key, img));+ cache.len() - 1+ }+ };+ let photo = &cache.get(at).ok_or("render cache lost an entry")?.1;+ draw_cell(&mut page, photo, item.cell, &self.style).map_err(|e| format!("{}: {e}", item.name))?;+ }+ out.push(PageRaster { width: w as u32, height: h as u32, ppi: self.ppi, rgb: page.rgb });+ }+ if !progress(done, "") {+ return Err("Print cancelled".into());+ }+ Ok(out)+ }+}++fn render(job: RenderJob) -> Result<Image16, String> {+ let rendered = job.run().rendered?;+ let deep = rendered.deep.ok_or("the render has no 16-bit samples")?;+ let DeepSamples::U16(rgb) = deep.samples else { return Err("the render is not 16-bit".into()) };+ if deep.space != OutputSpace::Rec2020 || rgb.len() != deep.width.saturating_mul(deep.height).saturating_mul(3) {+ return Err("the render is not Rec. 2020 RGB".into());+ }+ Ok(Image16 { w: deep.width, h: deep.height, rgb })+}++/// Sets a print job up: the cells for `photos` under `settings.layout`, one render job per cell.+pub fn prepare(session: &mut Session, settings: &PrintSettings, photos: &[PhotoId]) -> Result<Prepared, String> {+ let mut settings = settings.clone();+ settings.validate()?;+ let ppi = f64::from(settings.job.effective_ppi());+ let (pw_in, ph_in) = settings.layout.page_size()?;+ let (pw, ph) = ((pw_in * ppi).round() as usize, (ph_in * ppi).round() as usize);+ let page_px = (pw as u64).saturating_mul(ph as u64);+ if pw == 0 || ph == 0 || page_px > MAX_PAGE_PIXELS {+ return Err(format!("a page of {pw} x {ph} pixels is too large; lower the print resolution"));+ }+ let plan = plan_cells(&settings.layout, photos)?;+ if page_px.saturating_mul(plan.len() as u64) > MAX_JOB_PIXELS {+ return Err("the print is too large for memory; lower the print resolution or print fewer pages".into());+ }+ let style = CellStyle::of(&settings, ppi);+ let mut items = Vec::new();+ for (page, cells) in plan.iter().enumerate() {+ for (rect, id) in cells {+ let Some(cell) = px_rect(rect, ppi, pw, ph) else { continue };+ let photo = session.catalog.photo(*id).ok_or_else(|| format!("no photo {}", id.0))?;+ let name = photo.file_name.clone();+ let (nw, nh) = output_size(photo, &ExportOptions::default());+ let border = style.border_px.min(cell.w.min(cell.h).saturating_sub(1) / 2);+ let (aw, ah) = (cell.w - 2 * border, cell.h - 2 * border);+ let p = place(nw as f64, nh as f64, aw, ah, style.fill, style.rotate).ok_or("a photo has no size")?;+ let (rw, rh) = p.unturned();+ let job = session.export_job(*id, rw, rh, OutputSpace::Rec2020, OutputDepth::U16)?;+ items.push(Item { page, name, cell, key: (id.0, rw, rh), job });+ }+ }+ Ok(Prepared { pages: vec![(pw, ph); plan.len()], items, ppi: ppi as f32, background: rec2020_from_srgb8(settings.page.background), style })+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::print::layout::{GridSpec, Margins};++ const RED: [u16; 3] = [60000, 1000, 1000];+ const BLUE: [u16; 3] = [1000, 1000, 60000];+ const WHITE: [u16; 3] = [65535; 3];++ /// A `w` x `h` image whose left half is red and right half blue, with a green top row.+ fn halves(w: usize, h: usize) -> Image16 {+ let mut img = Image16::filled(w, h, RED).unwrap();+ img.fill_rect(w / 2, 0, w - w / 2, h, BLUE);+ img.fill_rect(0, 0, w, 1, [1000, 60000, 1000]);+ img+ }++ fn style() -> CellStyle {+ CellStyle { fill: false, rotate: false, border_px: 0, border: [0; 3], stroke_px: 0, stroke: [0; 3] }+ }++ fn at(img: &Image16, x: usize, y: usize) -> [u16; 3] {+ img.px(x, y).unwrap()+ }++ fn page() -> Image16 {+ Image16::filled(100, 100, WHITE).unwrap()+ }++ #[test]+ fn placement_fit_fill_and_rotation() {+ // 4:3 photo into a 2:1 area.+ let fit = place(400.0, 300.0, 200, 100, false, false).unwrap();+ assert_eq!((fit.w, fit.h, fit.rotated), (133, 100, false));+ let fill = place(400.0, 300.0, 200, 100, true, false).unwrap();+ assert_eq!((fill.w, fill.h), (200, 150));+ // A portrait photo in a landscape area: turning prints it larger.+ assert_eq!(place(300.0, 400.0, 400, 300, false, false).unwrap(), Placement { rotated: false, w: 225, h: 300 });+ let turned = place(300.0, 400.0, 400, 300, false, true).unwrap();+ assert_eq!((turned.rotated, turned.w, turned.h), (true, 400, 300));+ assert_eq!(turned.unturned(), (300, 400));+ // Filling a landscape cell with a portrait photo crops less when turned.+ let f = place(300.0, 400.0, 400, 300, true, true).unwrap();+ assert!(f.rotated && f.w >= 400 && f.h >= 300);+ // Matching orientation never turns.+ assert!(!place(400.0, 300.0, 400, 300, false, true).unwrap().rotated);+ assert!(!place(300.0, 300.0, 100, 100, false, true).unwrap().rotated);+ // Hostile input.+ for bad in [f64::NAN, f64::INFINITY, 0.0, -5.0] {+ assert!(place(bad, 10.0, 10, 10, false, false).is_none());+ assert!(place(10.0, bad, 10, 10, true, true).is_none());+ }+ assert!(place(10.0, 10.0, 0, 10, false, false).is_none());+ }++ #[test]+ fn fit_centres_the_photo() {+ let mut p = page();+ draw_cell(&mut p, &halves(40, 20), PxRect { x: 10, y: 10, w: 80, h: 80 }, &style()).unwrap();+ // 40x20 scaled to 80x40, centred vertically at y 30..70.+ assert_eq!(at(&p, 10, 50), RED);+ assert_eq!(at(&p, 89, 50), BLUE);+ assert_eq!(at(&p, 50, 20), WHITE, "above the photo");+ assert_eq!(at(&p, 50, 75), WHITE, "below the photo");+ assert_eq!(at(&p, 5, 50), WHITE, "outside the cell");+ }++ #[test]+ fn zoom_to_fill_crops_the_centre() {+ let mut p = page();+ let s = CellStyle { fill: true, ..style() };+ draw_cell(&mut p, &halves(40, 20), PxRect { x: 10, y: 10, w: 80, h: 80 }, &s).unwrap();+ // The photo scales to 160x80 and the centre 80 columns remain: the colour edge is mid-cell.+ for y in [10, 50, 89] {+ assert_ne!(at(&p, 10, y), WHITE);+ assert_ne!(at(&p, 89, y), WHITE);+ }+ assert_eq!(at(&p, 20, 50), RED);+ assert_eq!(at(&p, 80, 50), BLUE);+ // Nothing leaks outside the cell.+ assert_eq!(at(&p, 9, 50), WHITE);+ assert_eq!(at(&p, 90, 50), WHITE);+ assert_eq!(at(&p, 50, 9), WHITE);+ assert_eq!(at(&p, 50, 90), WHITE);+ }++ #[test]+ fn rotate_to_fit_turns_clockwise() {+ // A portrait 20x40 photo (red left, blue right) in a landscape 80x40 cell.+ let mut p = page();+ let cell = PxRect { x: 10, y: 10, w: 80, h: 40 };+ draw_cell(&mut p, &halves(20, 40), cell, &style()).unwrap();+ assert_eq!(at(&p, 20, 30), WHITE, "unturned the photo is a narrow strip in the middle");+ assert_eq!(at(&p, 45, 30), RED);+ let mut q = page();+ draw_cell(&mut q, &halves(20, 40), cell, &CellStyle { rotate: true, ..style() }).unwrap();+ // Turned clockwise the left half (red) becomes the top half and the photo spans the cell.+ assert_eq!(at(&q, 12, 12), RED, "{:?}", at(&q, 12, 12));+ assert_eq!(at(&q, 12, 48), BLUE);+ assert_eq!(at(&q, 50, 20), RED);+ assert_eq!(at(&q, 50, 40), BLUE);+ assert_eq!(at(&q, 11, 30), at(&q, 11, 30));+ }++ #[test]+ fn border_frames_the_photo_inside_the_cell() {+ let mut p = page();+ let green = [100, 60000, 100];+ let s = CellStyle { border_px: 5, border: green, fill: true, ..style() };+ draw_cell(&mut p, &halves(60, 60), PxRect { x: 10, y: 10, w: 60, h: 60 }, &s).unwrap();+ assert_eq!(at(&p, 10, 40), green);+ assert_eq!(at(&p, 14, 40), green);+ assert_eq!(at(&p, 15, 40), RED);+ assert_eq!(at(&p, 69, 40), green);+ assert_eq!(at(&p, 64, 40), BLUE);+ assert_eq!(at(&p, 40, 10), green);+ assert_eq!(at(&p, 40, 69), green);+ // A fitted photo gets the border hugging it, not the whole cell.+ let mut q = page();+ let s = CellStyle { border_px: 5, border: green, ..style() };+ draw_cell(&mut q, &halves(60, 30), PxRect { x: 0, y: 0, w: 100, h: 100 }, &s).unwrap();+ // The 90x90 area fits a 90x45 photo at y 27..72 inside a frame 5 px thick.+ assert_eq!(at(&q, 50, 23), green);+ assert_eq!(at(&q, 50, 22), green);+ assert_eq!(at(&q, 50, 21), WHITE);+ // A border wider than the cell leaves the photo visible.+ let mut r = page();+ let s = CellStyle { border_px: 500, border: green, ..style() };+ draw_cell(&mut r, &halves(10, 10), PxRect { x: 10, y: 10, w: 20, h: 20 }, &s).unwrap();+ assert_ne!(at(&r, 20, 20), WHITE);+ }++ #[test]+ fn stroke_is_drawn_inside_the_photo_edge() {+ let mut p = page();+ let black = [0, 0, 0];+ let s = CellStyle { stroke_px: 3, stroke: black, fill: true, ..style() };+ draw_cell(&mut p, &halves(60, 60), PxRect { x: 20, y: 20, w: 60, h: 60 }, &s).unwrap();+ for (x, y) in [(20, 40), (22, 40), (77, 40), (79, 40), (40, 20), (40, 22), (40, 77), (40, 79)] {+ assert_eq!(at(&p, x, y), black, "({x}, {y})");+ }+ assert_eq!(at(&p, 23, 40), RED);+ assert_eq!(at(&p, 76, 40), BLUE);+ assert_eq!(at(&p, 19, 40), WHITE, "the stroke does not grow the photo");+ // Corners are covered exactly once and a huge stroke stays within the photo.+ let mut q = page();+ let s = CellStyle { stroke_px: 1000, stroke: black, ..style() };+ draw_cell(&mut q, &halves(10, 10), PxRect { x: 20, y: 20, w: 40, h: 40 }, &s).unwrap();+ assert_eq!(at(&q, 40, 40), black);+ assert_eq!(at(&q, 19, 40), WHITE);+ assert_eq!(at(&q, 60, 40), WHITE);+ }++ #[test]+ fn colours_are_rec2020_encoded() {+ assert_eq!(rec2020_from_srgb8([255; 3]), [65535; 3]);+ assert_eq!(rec2020_from_srgb8([0; 3]), [0; 3]);+ let grey = rec2020_from_srgb8([128; 3]);+ assert!(grey[0].abs_diff(grey[1]) < 3 && grey[1].abs_diff(grey[2]) < 3);+ // sRGB red sits inside the Rec. 2020 gamut: its green and blue are not zero.+ let red = rec2020_from_srgb8([255, 0, 0]);+ assert!(red[0] < 65535 && red[1] > 0);+ }++ #[test]+ fn resize_preserves_flat_colour_and_edges() {+ let img = halves(64, 32);+ for (w, h) in [(32, 16), (128, 64), (50, 70), (1, 1), (64, 31)] {+ let r = img.resized(w, h).unwrap();+ assert_eq!((r.w, r.h), (w, h));+ assert_eq!(r.rgb.len(), w * h * 3);+ }+ let flat = Image16::filled(40, 30, [1234, 5678, 9999]).unwrap().resized(17, 61).unwrap();+ assert!(flat.rgb.chunks(3).all(|p| p == [1234, 5678, 9999]));+ assert!(img.resized(0, 5).is_err());+ let r = img.resized(32, 16).unwrap();+ assert_eq!(at(&r, 4, 8), RED);+ assert_eq!(at(&r, 28, 8), BLUE);+ }++ #[test]+ fn rotate_and_blit_are_clipped() {+ let img = halves(3, 2);+ let r = img.rotated_cw().unwrap();+ assert_eq!((r.w, r.h), (2, 3));+ let mut p = page();+ p.blit(&img, 0, 0, 99, 99, 10, 10);+ assert_eq!(at(&p, 99, 99), at(&img, 0, 0));+ p.blit(&img, 5, 5, 0, 0, 3, 3);+ p.fill_rect(95, 95, 50, 50, RED);+ assert_eq!(at(&p, 99, 99), RED);+ p.fill_rect(usize::MAX, usize::MAX, usize::MAX, usize::MAX, RED);+ }++ fn settings(style: Style) -> PrintSettings {+ let mut s = PrintSettings::default();+ s.layout.style = style;+ s.layout.page.paper = "4x6".into();+ s.layout.page.margins = Margins::uniform(0.5);+ s.job.ppi = 100.0;+ s+ }++ #[test]+ fn plans_follow_the_layout_style() {+ let ids: Vec<PhotoId> = (1..=5).map(PhotoId).collect();+ let mut s = settings(Style::ContactSheet);+ s.layout.grid = GridSpec { columns: 2, rows: 2, ..Default::default() };+ let plan = plan_cells(&s.layout, &ids).unwrap();+ assert_eq!(plan.iter().map(Vec::len).collect::<Vec<_>>(), vec![4, 1]);+ assert_eq!(plan[1][0].1, PhotoId(5));+ let one = plan_cells(&settings(Style::SingleImage).layout, &ids).unwrap();+ assert_eq!(one.len(), 5);+ assert!(plan_cells(&s.layout, &[]).is_err());+ assert!(plan_cells(&s.layout, &vec![PhotoId(1); MAX_PHOTOS + 1]).is_err());++ let mut pkg = settings(Style::PicturePackage);+ assert!(plan_cells(&pkg.layout, &ids).is_err(), "no cells yet");+ pkg.layout.add_cell(1.0, 1.0).unwrap();+ pkg.layout.add_cell(2.0, 2.0).unwrap();+ let plan = plan_cells(&pkg.layout, &ids).unwrap();+ assert_eq!(plan.len(), 1);+ assert!(plan[0].iter().all(|(_, p)| *p == PhotoId(1)), "picture package repeats the first photo");++ let mut custom = settings(Style::CustomPackage);+ let a = custom.layout.add_cell(1.0, 1.0).unwrap();+ custom.layout.add_cell(1.0, 1.0).unwrap();+ custom.layout.set_cell_photo(a, Some(3)).unwrap();+ let plan = plan_cells(&custom.layout, &ids).unwrap();+ assert_eq!((plan[0][0].1, plan[0][1].1), (PhotoId(3), PhotoId(1)));+ let blank_page = {+ custom.layout.new_page().unwrap();+ plan_cells(&custom.layout, &ids).unwrap()+ };+ assert_eq!(blank_page.iter().map(Vec::len).collect::<Vec<_>>(), vec![2, 0]);+ }++ fn first_ids(s: &Session, n: usize) -> Vec<PhotoId> {+ s.catalog.photos().take(n).map(|p| p.id).collect()+ }++ #[test]+ fn composes_pages_from_real_photos() {+ let mut s = Session::with_demo();+ let ids = first_ids(&s, 3);+ let mut set = settings(Style::ContactSheet);+ set.layout.grid = GridSpec { columns: 1, rows: 2, spacing_x: 0.0, spacing_y: 0.0, keep_square: false };+ set.page.background = [200, 30, 30];+ set.image.zoom_to_fill = true;+ set.image.stroke_enabled = true;+ set.image.stroke_width_pt = 2.0;+ set.image.stroke_color = [0, 0, 0];+ let work = prepare(&mut s, &set, &ids).unwrap();+ assert_eq!((work.len(), work.pages()), (3, 2));+ let mut steps = Vec::new();+ let pages = work+ .run(&mut |i, name| {+ steps.push((i, name.to_string()));+ true+ })+ .unwrap();+ assert_eq!(steps.iter().map(|s| s.0).collect::<Vec<_>>(), vec![0, 1, 2, 3]);+ assert_eq!(pages.len(), 2);+ let first = &pages[0];+ assert_eq!((first.width, first.height, first.ppi), (400, 600, 100.0));+ assert_eq!(first.rgb.len(), 400 * 600 * 3);+ let bg = rec2020_from_srgb8([200, 30, 30]);+ let px = |p: &PageRaster, x: usize, y: usize| {+ let i = (y * p.width as usize + x) * 3;+ [p.rgb[i], p.rgb[i + 1], p.rgb[i + 2]]+ };+ assert_eq!(px(first, 5, 5), bg, "margin shows the page background");+ assert_eq!(px(first, 395, 595), bg);+ // Zoom to fill: the top-left photo pixel (inside the 2 pt = 3 px stroke) is the stroke colour.+ assert_eq!(px(first, 50, 50), [0, 0, 0]);+ let centre = px(first, 200, 150);+ assert_ne!(centre, bg);+ assert_ne!(centre, [0, 0, 0]);+ // The second page holds the third photo in the first cell only: the second cell is bare.+ let second = &pages[1];+ assert_ne!(px(second, 200, 150), bg);+ assert_eq!(px(second, 200, 450), bg);+ // Cancelling gives no pages.+ let work = prepare(&mut s, &set, &ids).unwrap();+ assert!(work.run(&mut |i, _| i < 1).is_err());+ }++ #[test]+ fn package_renders_each_size_and_border() {+ let mut s = Session::with_demo();+ let ids = first_ids(&s, 1);+ let mut set = settings(Style::PicturePackage);+ set.layout.add_cell(1.5, 1.0).unwrap();+ set.layout.add_cell(1.5, 1.0).unwrap();+ set.image.border_enabled = true;+ set.image.border_width = 0.1;+ set.image.border_color = [10, 200, 10];+ let pages = prepare(&mut s, &set, &ids).unwrap().run(&mut |_, _| true).unwrap();+ assert_eq!(pages.len(), 1);+ let green = rec2020_from_srgb8([10, 200, 10]);+ let cell = set.layout.cells[0].rect;+ let (x0, y0) = ((cell.x * 100.0).round() as usize, (cell.y * 100.0).round() as usize);+ let at = |x: usize, y: usize| {+ let i = (y * 400 + x) * 3;+ pages[0].rgb[i..i + 3].to_vec()+ };+ // The frame touches the cell edge on the photo's limiting axis: 10 px (0.1 in) of border all round.+ let mid = (x0 + 75, y0 + 50);+ assert_ne!(at(mid.0, mid.1), green.to_vec(), "the photo, not the border, is in the middle");+ let green_px = (y0..y0 + 100).flat_map(|y| (x0..x0 + 150).map(move |x| (x, y))).filter(|&(x, y)| at(x, y) == green.to_vec()).count();+ assert!(green_px > 1000, "the border frames the photo inside its cell: {green_px} border pixels");+ }++ #[test]+ fn caps_and_hostile_settings_are_refused() {+ let mut s = Session::with_demo();+ let ids = first_ids(&s, 1);+ let mut set = settings(Style::SingleImage);+ set.layout.page.paper = "custom".into();+ set.layout.page.custom_width = 60.0;+ set.layout.page.custom_height = 60.0;+ set.job.ppi = 720.0;+ assert!(prepare(&mut s, &set, &ids).is_err(), "a 60 in page at 720 ppi is far beyond the page cap");+ let mut set = settings(Style::SingleImage);+ set.job.ppi = f32::NAN;+ assert!(prepare(&mut s, &set, &ids).is_err());+ let mut set = settings(Style::SingleImage);+ set.image.border_width = f64::NAN;+ assert!(prepare(&mut s, &set, &ids).is_err());+ set.image.border_width = 0.1;+ set.image.stroke_width_pt = -1.0;+ assert!(prepare(&mut s, &set, &ids).is_err());+ assert!(prepare(&mut s, &settings(Style::SingleImage), &[PhotoId(999_999)]).is_err());+ assert!(prepare(&mut s, &settings(Style::SingleImage), &[]).is_err());+ let set = settings(Style::SingleImage);+ assert!(prepare(&mut s, &set, &vec![ids[0]; 101]).is_err(), "more than 100 pages");+ // 100 pages of 4x6 at 100 ppi is 24 Mpx: allowed; at 720 ppi it would be over the job cap.+ let mut big = settings(Style::SingleImage);+ big.job.ppi = 720.0;+ assert!(prepare(&mut s, &big, &vec![ids[0]; 60]).is_err());+ }+}diff --git a/crates/engine/src/print/mod.rs b/crates/engine/src/print/mod.rsindex d309dbd6f..a9ca3e35f 100644--- a/crates/engine/src/print/mod.rs+++ b/crates/engine/src/print/mod.rs@@ -1,4 +1,83 @@//! The Print module: page layout, composition of pages and PDF output.//!-//! [`layout`] is the pure page model (paper, margins, cells); the rest of the module renders it.+//! [`layout`] is the pure page model (paper, margins, cells); [`compose`] renders a layout and its+//! photos to [`PageRaster`]s; [`template`] holds the saved settings; [`output`] writes the pages+//! as a PDF.+pub mod compose;pub mod layout;+pub mod output;+pub mod template;++use serde::{Deserialize, Serialize};++/// Lowest and highest print resolution, pixels per inch.+pub const MIN_PPI: f32 = 72.0;+pub const MAX_PPI: f32 = 720.0;+/// Pages a single print may have.+pub const MAX_JOB_PAGES: usize = 100;+/// Most pixels one page may have (about 100 megapixels: A3 at 720 ppi is 60).+pub const MAX_PAGE_PIXELS: u64 = 100_000_000;+/// Most pixels a print job may hold across all its pages (6 bytes each in memory).+pub const MAX_JOB_PIXELS: u64 = 200_000_000;++/// One composed page, ready for output: row-major interleaved RGB, 16 bits per sample, encoded in+/// Rec. 2020 ([`lightcraft_pipeline::OutputSpace::Rec2020`]; the transfer curve is that space's).+/// The page covers its paper edge to edge: `width / ppi` by `height / ppi` inches.+#[derive(Clone, Debug, PartialEq)]+pub struct PageRaster {+ pub width: u32,+ pub height: u32,+ pub ppi: f32,+ pub rgb: Vec<u16>,+}++/// How a print job is produced (Lightroom's Print Job panel; colour management joins it later).+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]+#[serde(default, rename_all = "camelCase", deny_unknown_fields)]+pub struct PrintJob {+ /// Print resolution in pixels per inch, 72 to 720.+ pub ppi: f32,+}++impl Default for PrintJob {+ fn default() -> Self {+ Self { ppi: 240.0 }+ }+}++impl PrintJob {+ /// The resolution to render at: [`Self::ppi`] clamped to 72..=720 (240 for NaN).+ pub fn effective_ppi(&self) -> f32 {+ if self.ppi.is_finite() { self.ppi.clamp(MIN_PPI, MAX_PPI) } else { 240.0 }+ }++ /// Rejects a resolution outside the supported range (commands and templates, which should+ /// say so rather than silently clamp).+ pub fn validate(&self) -> Result<(), String> {+ if self.ppi.is_finite() && (MIN_PPI..=MAX_PPI).contains(&self.ppi) {+ Ok(())+ } else {+ Err(format!("ppi must be a number from {MIN_PPI} to {MAX_PPI}"))+ }+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn ppi_is_clamped_and_validated() {+ assert_eq!(PrintJob::default().effective_ppi(), 240.0);+ for (v, e) in [(10.0, 72.0), (5000.0, 720.0), (f32::NAN, 240.0), (f32::INFINITY, 240.0), (300.0, 300.0)] {+ assert_eq!(PrintJob { ppi: v }.effective_ppi(), e);+ }+ assert!(PrintJob { ppi: 300.0 }.validate().is_ok());+ for bad in [0.0, 71.0, 721.0, f32::NAN, f32::NEG_INFINITY] {+ assert!(PrintJob { ppi: bad }.validate().is_err());+ }+ let j: PrintJob = serde_json::from_str("{}").unwrap();+ assert_eq!(j, PrintJob::default());+ assert!(serde_json::from_str::<PrintJob>(r#"{"dpi": 1}"#).is_err());+ }+}diff --git a/crates/engine/src/print/output.rs b/crates/engine/src/print/output.rsnew file mode 100644index 000000000..f058ccf0b--- /dev/null+++ b/crates/engine/src/print/output.rs@@ -0,0 +1,103 @@+//! Writes composed pages as a PDF.+//!+//! Interim writer: each page is converted from Rec. 2020 to 8-bit sRGB and embedded as a JPEG+//! covering the paper. Colour-managed output replaces the body of [`write`], not its signature.+use super::{MAX_JOB_PAGES, PageRaster, PrintJob};+use crate::contact_sheet::Pdf;+use crate::export::{ExportFormat, ExportOptions, encode_image};+use lightcraft_color::transfer::encode_srgb8;+use lightcraft_color::{REC2020, SRGB};+use lightcraft_pipeline::OutputSpace;+use lightcraft_raster::Rgba8;++/// Largest PDF produced, bytes.+const MAX_PDF_BYTES: usize = 256 * 1024 * 1024;++/// A Rec. 2020 page as 8-bit sRGB (out-of-gamut colours are clipped).+pub fn page_to_srgb8(page: &PageRaster) -> Result<Rgba8, String> {+ let (w, h) = (page.width as usize, page.height as usize);+ let n = w.checked_mul(h).ok_or("page too large")?;+ if n == 0 || page.rgb.len() != n.checked_mul(3).ok_or("page too large")? {+ return Err("a page's pixel data does not match its size".into());+ }+ let trc = OutputSpace::Rec2020.trc();+ // 16-bit Rec. 2020 code → linear light, once per code value.+ let lut: Vec<f32> = (0..=u16::MAX).map(|v| trc.decode(f32::from(v) / 65535.0)).collect();+ let m = REC2020.to_space(&SRGB).to_f32();+ let mut out = Rgba8::new(w, h);+ for (dst, src) in out.data.iter_mut().zip(page.rgb.as_chunks::<3>().0) {+ let l = src.map(|v| lut.get(usize::from(v)).copied().unwrap_or(0.0));+ let row = |r: usize| m.get(r).map_or(0.0, |m| m[0] * l[0] + m[1] * l[1] + m[2] * l[2]);+ *dst = [encode_srgb8(row(0)), encode_srgb8(row(1)), encode_srgb8(row(2)), 255];+ }+ Ok(out)+}++/// The PDF for `pages` (all the same size): one page per raster, its MediaBox the paper size in+/// points (`pixels / ppi * 72`) with the image covering it.+pub fn write(pages: &[PageRaster], job: &PrintJob, title: &str) -> Result<Vec<u8>, String> {+ let _ = (job, title);+ let first = pages.first().ok_or("nothing to print")?;+ if pages.len() > MAX_JOB_PAGES {+ return Err(format!("a print is limited to {MAX_JOB_PAGES} pages"));+ }+ if !(first.ppi.is_finite() && first.ppi > 0.0) {+ return Err("a page has no resolution".into());+ }+ let points = |px: u32| f64::from(px) / f64::from(first.ppi) * 72.0;+ let size = (points(first.width), points(first.height));+ let mut pdf = Pdf::new(pages.len(), size);+ for (i, page) in pages.iter().enumerate() {+ if (page.width, page.height) != (first.width, first.height) {+ return Err("all pages of a PDF must be the same size".into());+ }+ let rgba = page_to_srgb8(page)?;+ let jpg = encode_image(&rgba, &ExportOptions { format: ExportFormat::Jpeg, quality: 92, ..Default::default() })?;+ if pdf.bytes.len().saturating_add(jpg.len()) > MAX_PDF_BYTES {+ return Err("the PDF would exceed 256 MiB; lower the print resolution or print fewer pages".into());+ }+ pdf.page(i, &jpg, page.width as usize, page.height as usize);+ }+ Ok(pdf.finish())+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::print::compose::rec2020_from_srgb8;++ fn raster(w: u32, h: u32, srgb: [u8; 3]) -> PageRaster {+ let c = rec2020_from_srgb8(srgb);+ PageRaster { width: w, height: h, ppi: 100.0, rgb: (0..w * h).flat_map(|_| c).collect() }+ }++ #[test]+ fn colours_survive_the_round_trip() {+ for c in [[255u8, 255, 255], [0, 0, 0], [128, 128, 128], [200, 30, 30], [10, 200, 90]] {+ let px = page_to_srgb8(&raster(2, 2, c)).unwrap().data[0];+ for k in 0..3 {+ assert!(px[k].abs_diff(c[k]) <= 1, "{c:?} -> {px:?}");+ }+ }+ assert!(page_to_srgb8(&PageRaster { width: 2, height: 2, ppi: 100.0, rgb: vec![0; 5] }).is_err());+ assert!(page_to_srgb8(&PageRaster { width: 0, height: 2, ppi: 100.0, rgb: vec![] }).is_err());+ }++ #[test]+ fn pdf_pages_have_the_paper_size() {+ let pages = [raster(425, 550, [255, 255, 255]), raster(425, 550, [0, 0, 255])];+ let bytes = write(&pages, &PrintJob::default(), "t").unwrap();+ let text = String::from_utf8_lossy(&bytes);+ assert!(text.starts_with("%PDF-1.4"));+ assert!(text.contains("/Count 2"));+ assert!(text.contains("/MediaBox [0 0 306.00 396.00]"), "4.25 x 5.5 in is 306 x 396 pt");+ assert!(text.contains("/Width 425 /Height 550"));+ assert!(write(&[], &PrintJob::default(), "t").is_err());+ let mixed = [raster(10, 10, [0; 3]), raster(10, 12, [0; 3])];+ assert!(write(&mixed, &PrintJob::default(), "t").is_err());+ let bad = PageRaster { ppi: f32::NAN, ..raster(4, 4, [0; 3]) };+ assert!(write(&[bad], &PrintJob::default(), "t").is_err());+ let zero = PageRaster { ppi: 0.0, ..raster(4, 4, [0; 3]) };+ assert!(write(&[zero], &PrintJob::default(), "t").is_err());+ }+}diff --git a/crates/engine/src/print/template.rs b/crates/engine/src/print/template.rsnew file mode 100644index 000000000..2fd74ca60--- /dev/null+++ b/crates/engine/src/print/template.rs@@ -0,0 +1,27 @@+//! The settings a print is made from, and (with the saved-template commands) what a print+//! template stores.+use super::PrintJob;+use super::compose::{ImageSettings, PageStyle};+use super::layout::{Guides, Layout};+use serde::{Deserialize, Serialize};++/// Layout, image settings, page, guides and job: the whole Print module state.+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]+#[serde(default, rename_all = "camelCase", deny_unknown_fields)]+pub struct PrintSettings {+ pub layout: Layout,+ pub image: ImageSettings,+ pub page: PageStyle,+ pub guides: Guides,+ pub job: PrintJob,+}++impl PrintSettings {+ /// Checks every part; run on anything that did not come from the setters.+ pub fn validate(&mut self) -> Result<(), String> {+ self.layout.validate()?;+ self.image.validate()?;+ self.guides.validate()?;+ self.job.validate()+ }+}diff --git a/docs/gaps.md b/docs/gaps.mdindex 724758c8a..4c3a84ef0 100644--- a/docs/gaps.md+++ b/docs/gaps.md@@ -72,6 +72,7 @@ Beta-blocking gaps (B) total **~230–430 h**; with the stability and platform w| Date | Change | Summary ||---|---|---|+| 2026-10-12 | minor | Gap 15: print pages compose in the engine (fit / Zoom to Fill, Rotate to Fit, border, stroke, background) with an interim PDF writer; commands and UI still to land || 2026-10-12 | minor | Gap 15: the Print layout model (paper sizes, margins, grid, package cells, Auto Layout packer, snapping) is in the engine; commands, composition and UI still to land || 2026-10-11 | minor | Reviewed against main after 0.6.0: CR3 entry names the CRX variants `crx.rs` still refuses and the R7 / R6 Mark II C-RAW state (decoding, not verified, so the measured numbers don't move); CI and Windows / Linux entries note the riscv64 release build (#844); R7 fix added to Closed recently. Panel docking (UI.9, #869) closes no listed gap || 2026-10-11 | minor | Camera colour entry: raws with a black-and-white camera JPEG take its tone curve (#577); gap not closed |diff --git a/docs/parity-checklist.md b/docs/parity-checklist.mdindex ee965a945..e984542c8 100644--- a/docs/parity-checklist.md+++ b/docs/parity-checklist.md@@ -1,6 +1,6 @@# Lightroom parity checklist-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (LRC-PRINT-LAYOUT: print layout model; rapid slider entry; LR-PROF-CAMERACOLOR: tone curve from black-and-white camera JPEGs; LR-VIEW-ZOOM, LR-VIEW-COMPARE: Compare and Reference zoom windows; LR-IMP-FORMATS, LR-IMP-CAMERA-COVERAGE: EOS R5 Mark II CR3 decodes; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md; filesystem history retry/Undo/Redo evidence; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** minor (LRC-PRINT-IMAGESETTINGS: print page composition (fit / Zoom to Fill, Rotate to Fit, border, stroke, background); LRC-PRINT-LAYOUT: print layout model; rapid slider entry; LR-PROF-CAMERACOLOR: tone curve from black-and-white camera JPEGs; LR-VIEW-ZOOM, LR-VIEW-COMPARE: Compare and Reference zoom windows; LR-IMP-FORMATS, LR-IMP-CAMERA-COVERAGE: EOS R5 Mark II CR3 decodes; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md; filesystem history retry/Undo/Redo evidence; renamed from `parity.md`; Top gaps moved to gaps.md, shortcut notes to ui-parity.md) · **Target:** Adobe Lightroom Classic 15.5 / Lightroom 9.6The measured, row-by-row checklist: one row per Lightroom feature, menu item and shortcut, what wehave and what is missing. It answers *does the feature exist?* (feature breadth). Whether it is good@@ -748,11 +748,11 @@ From `08-lightroom-classic-extras.md` (Classic-only features) and part 2 of `06-| LRC-SS-PLAYBACK | Slideshow playback | P2 | ⬜ | | || LRC-SS-EXPORT | Slideshow export | P2 | ⬜ | | || LRC-PRINT-LAYOUTSTYLE | Print layout styles | P2 | 🟡 | `cmd:dialog.contactSheet`, `cmd:export.contactSheet`, `crates/engine/src/contact_sheet.rs` | paginated contact sheets; single-image/custom package layouts missing |-| LRC-PRINT-IMAGESETTINGS | Print image settings | P2 | ⬜ | | |+| LRC-PRINT-IMAGESETTINGS | Print image settings | P2 | ⬜ | `crates/engine/src/print/compose.rs` | Zoom to Fill, Rotate to Fit, Photo Border (package styles), Inner Stroke and page background compose in the engine (16-bit Rec. 2020 pages, tested on pixels); no command or UI yet || LRC-PRINT-LAYOUT | Print layout | P2 | 🟡 | `cmd:export.contactSheet`, `crates/ui-egui/src/panels/dialogs.rs`, `crates/engine/src/print/layout.rs` | A4/Letter, portrait/landscape, 1–8 columns and 1–10 rows; fixed margins and spacing. The new layout model (ten paper sizes + custom, orientation, margins, grid with spacing and square cells, package cells with Auto Layout packing) is in the engine but not yet reachable from a command or the UI || LRC-PRINT-GUIDES | Print guides | P2 | ⬜ | | || LRC-PRINT-CELLS | Picture-package cells | P2 | ⬜ | `crates/engine/src/print/layout.rs` | cell model, deterministic packer, stacking order and snapping exist in the engine; no command or UI yet |-| LRC-PRINT-PAGE | Print page options | P2 | 🟡 | `cmd:export.contactSheet`, `crates/engine/src/contact_sheet.rs` | optional filename captions; no page backgrounds/identity plates |+| LRC-PRINT-PAGE | Print page options | P2 | 🟡 | `cmd:export.contactSheet`, `crates/engine/src/contact_sheet.rs`, `crates/engine/src/print/compose.rs` | optional filename captions; page background colour composes in the engine (no command or UI yet); no identity plates || LRC-PRINT-JOB | Print job & colour management | P2 | 🟡 | `cmd:export.contactSheet`, `cmd:app.contactSheet`, `crates/ui-egui/src/export_task.rs` | PDF export at fixed 150 dpi in sRGB, current edits, background progress/cancel and original protection; no native printer integration, ICC soft proof/print profiles or selectable resolution || LRC-PRINT-TEMPLATES | Print templates | P2 | ⬜ | | || LRC-WEB-LAYOUT | Web gallery layouts | OOS | 🚫 | | |@@ -787,6 +787,7 @@ Latin stays upright. Advanced Japanese composition remains open. Regression cove| Date | Change | Summary ||---|---|---|+| 2026-10-12 | minor | LRC-PRINT-IMAGESETTINGS: `print/compose.rs` composes pages (Zoom to Fill, Rotate to Fit, Photo Border, Inner Stroke, background) from the layout model into 16-bit Rec. 2020 `PageRaster`s, with an interim sRGB PDF writer in `print/output.rs`; rows stay until commands and UI reach them || 2026-10-12 | minor | LRC-PRINT-LAYOUT: the Print layout model (paper, margins, grid, package cells, Auto Layout packer, snapping) lands in `print/layout.rs`; no row changes status until commands and UI follow || 2026-10-11 | minor | KEY-SLIDER-TYPE: honor immediate Return/Escape and keep typed keys in the value editor; add regression references || 2026-10-11 | minor | LR-PROF-CAMERACOLOR: raws with a black-and-white camera JPEG take its tone curve (issue #577) |