LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
M4.4: Upright — Auto/Level/Vertical/Full from detected lines + Guided upright (up to 4 guides)
Brandon Thomasb00dda4cecae
diff --git a/crates/develop/src/settings.rs b/crates/develop/src/settings.rsindex b8f0e5fc2..fa257c367 100644--- a/crates/develop/src/settings.rs+++ b/crates/develop/src/settings.rs@@ -1,7 +1,7 @@//! The develop settings schema. Every field has a neutral default; serde uses `#[serde(default)]` so//! older/newer files load (unknown fields are ignored, missing fields take defaults).-use lightcraft_geom::{CropGeometry, Orientation, Point};+use lightcraft_geom::{CropGeometry, Homography, Orientation, Point};use serde::{Deserialize, Serialize};pub const SCHEMA_VERSION: u32 = 1;@@ -493,8 +493,13 @@ pub enum Upright {#[serde(default)]pub struct Geometry {pub upright: Upright,- /// Guided Upright guides (normalized image coords), up to 4 line segments.+ /// Guided Upright guides, up to 4 line segments, in normalized coordinates of the lens-corrected+ /// (pre-perspective) oriented image.pub guides: Vec<(Point, Point)>,+ /// The automatic Upright correction found by analysis for `upright` (Auto/Level/Vertical/Full), as a+ /// homography lens-corrected → transformed in centred coordinates (`(p − centre) / (long edge / 2)`).+ /// Stored so previews and exports use the identical transform; recomputed by `geometry.upright`.+ pub upright_transform: Option<Homography>,pub vertical: f64,pub horizontal: f64,pub rotate: f64,@@ -510,6 +515,7 @@ impl Default for Geometry {Self {upright: Upright::Off,guides: Vec::new(),+ upright_transform: None,vertical: 0.0,horizontal: 0.0,rotate: 0.0,diff --git a/crates/engine/src/cmd/develop.rs b/crates/engine/src/cmd/develop.rsindex a53f31700..b7b790670 100644--- a/crates/engine/src/cmd/develop.rs+++ b/crates/engine/src/cmd/develop.rs@@ -1,7 +1,7 @@//! Develop commands. All operate on the active photo unless `ids` are given (sync).use lightcraft_catalog::{Op, PhotoId, Version};-use lightcraft_develop::{DevelopSettings, Preset, Section, SettingsGroup, Treatment, WbMode, controls};+use lightcraft_develop::{DevelopSettings, Preset, Section, SettingsGroup, Treatment, Upright, WbMode, controls};use lightcraft_geom::{CropGeometry, Point, Rect, crop_fit_angle};use serde_json::{Value, json};@@ -382,6 +382,66 @@ pub fn specs() -> Vec<CommandSpec> {Ok(())})}),+ // ---- geometry: Upright+ cmd!(+ "geometry.upright",+ "Upright",+ [],+ None,+ "{mode: off|auto|guided|level|vertical|full} — analyses the photo (line segments → vanishing points) and stores the correction; run again to update after lens changes",+ has_active,+ |s, p| {+ let mode: Upright =+ serde_json::from_value(p.get("mode").cloned().unwrap_or(json!("auto"))).map_err(|e| bad("geometry.upright", e.to_string()))?;+ let id = active(s, "geometry.upright")?;+ let d = s.develop_of(id).unwrap_or_default();+ let transform = match mode {+ Upright::Off | Upright::Guided => None,+ m => {+ let src = s.source_now(id, SourceLevel::Preview).map_err(|e| bad("geometry.upright", e))?;+ let info = s.catalog.photo(id).map(|p| crate::media::source_info(p)).unwrap_or_default();+ Some(lightcraft_pipeline::upright::auto_transform(&src, &info, &d, m))+ }+ };+ edit(s, "geometry.upright", "Upright", |d| {+ d.geometry.upright = mode;+ d.geometry.upright_transform = transform;+ Ok(())+ })?;+ Ok(json!({"mode": mode, "transform": transform}))+ }+ ),+ cmd!(+ "geometry.guides",+ "Guided Upright Guides",+ [],+ None,+ "{guides: [[x0,y0,x1,y1], …] (≤ 4, normalized coords of the lens-corrected image), add?: bool (append one guide, dropping the oldest beyond 4)} — switches Upright to Guided",+ has_active,+ |s, p| {+ let parse = |v: &Value| -> Option<(Point, Point)> {+ let a: Vec<f64> = v.as_array()?.iter().filter_map(Value::as_f64).collect();+ (a.len() == 4 && a.iter().all(|x| x.is_finite())).then(|| (Point::new(a[0], a[1]), Point::new(a[2], a[3])))+ };+ let guides: Vec<(Point, Point)> =+ p.get("guides").and_then(Value::as_array).map(|a| a.iter().filter_map(parse).collect()).unwrap_or_default();+ let add = bool_or(p, "add", false);+ edit(s, "geometry.guides", "Guided Upright", |d| {+ if add {+ d.geometry.guides.extend(guides);+ } else {+ d.geometry.guides = guides;+ }+ let n = d.geometry.guides.len();+ if n > 4 {+ d.geometry.guides.drain(..n - 4);+ }+ d.geometry.upright = Upright::Guided;+ d.geometry.upright_transform = None;+ Ok(())+ })+ }+ ),// ---- copy / paste / synccmd!("develop.copy",diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rsindex 6630910cf..a6623710a 100644--- a/crates/engine/src/tests.rs+++ b/crates/engine/src/tests.rs@@ -166,3 +166,26 @@ fn command_sweep() {}assert!(s.commands().len() >= 70, "{}", s.commands().len());}++#[test]+fn upright_and_guides_commands() {+ let mut s = demo();+ let r = s.execute("geometry.upright", &json!({"mode": "level"})).unwrap();+ assert_eq!(r["mode"], "level");+ let d = active_dev(&s);+ assert_eq!(d.geometry.upright, lightcraft_develop::Upright::Level);+ assert!(d.geometry.upright_transform.is_some(), "analysis result is stored");+ s.execute("geometry.upright", &json!({"mode": "off"})).unwrap();+ assert!(active_dev(&s).geometry.upright_transform.is_none());+ for i in 0..5 {+ let x = 0.1 + 0.15 * i as f64;+ s.execute("geometry.guides", &json!({"guides": [[x, 0.2, x + 0.02, 0.8]], "add": true})).unwrap();+ }+ let d = active_dev(&s);+ assert_eq!(d.geometry.upright, lightcraft_develop::Upright::Guided);+ assert_eq!(d.geometry.guides.len(), 4, "at most four guides");+ assert!((d.geometry.guides[0].0.x - 0.25).abs() < 1e-9, "oldest dropped");+ let id = s.active().unwrap();+ assert!(s.render_now(id, 160, 160).is_ok());+ assert!(s.execute("geometry.upright", &json!({"mode": "sideways"})).is_err());+}diff --git a/crates/pipeline/src/geometry.rs b/crates/pipeline/src/geometry.rsindex 38aa10174..5742c8ab4 100644--- a/crates/pipeline/src/geometry.rs+++ b/crates/pipeline/src/geometry.rs@@ -223,11 +223,11 @@ impl Frame {/// The perspective homography of the settings (Upright, then the manual Transform sliders), lens-corrected →/// transformed, in centred coordinates.-pub fn perspective(s: &DevelopSettings, _ow: f64, _oh: f64) -> Homography {+pub fn perspective(s: &DevelopSettings, ow: f64, oh: f64) -> Homography {if !s.section_enabled("geometry") {return Homography::IDENTITY;}- crate::transform::manual(&s.geometry)+ crate::transform::manual(&s.geometry).mul(&crate::upright::homography(&s.geometry, ow, oh))}/// One resample through the warp: `o2t` maps output px → transformed px, the warp maps those to source pxdiff --git a/crates/pipeline/src/lib.rs b/crates/pipeline/src/lib.rsindex 9ca2ab09d..c66026bab 100644--- a/crates/pipeline/src/lib.rs+++ b/crates/pipeline/src/lib.rs@@ -28,6 +28,7 @@ pub mod profiles;pub mod spots;mod tone;pub mod transform;+pub mod upright;use lightcraft_develop::{DevelopSettings, Treatment};use lightcraft_raster::{Histogram, Plane, Rgb32f, Rgba8, par_rows};@@ -121,6 +122,7 @@ pub fn render(src: &Rgb32f, info: &SourceInfo, s: &DevelopSettings, req: &Render};let mut t = prof.then(std::time::Instant::now);let s = &*profiles::effective(s);+ let s = &*upright::resolve(src, info, s);let frame = frame_for(src, info, s, req.apply_crop);let (w, h) = frame.fit(req.max_w, req.max_h);let mut img = frame.sample(src, w, h);diff --git a/crates/pipeline/src/optics.rs b/crates/pipeline/src/optics.rsindex 96ab6f7e7..7c2cec270 100644--- a/crates/pipeline/src/optics.rs+++ b/crates/pipeline/src/optics.rs@@ -268,7 +268,8 @@ pub fn estimate_lateral_ca(img: &Rgb32f) -> [f64; 2] {v}-fn fingerprint(img: &Rgb32f) -> u64 {+/// Cheap content fingerprint of an image (dimensions + 512 sampled pixels), for analysis caches.+pub(crate) fn fingerprint(img: &Rgb32f) -> u64 {let mut h: u64 = 0xcbf2_9ce4_8422_2325 ^ ((img.width as u64) << 32 | img.height as u64);let n = img.data.len();for i in 0..512usize {diff --git a/crates/pipeline/src/tests_geometry.rs b/crates/pipeline/src/tests_geometry.rsindex 6d3c097cc..142ec19b2 100644--- a/crates/pipeline/src/tests_geometry.rs+++ b/crates/pipeline/src/tests_geometry.rs@@ -274,3 +274,159 @@ fn transforms_preview_matches_export() {let err = mean_abs_diff_downscaled(&small, &big);assert!(err < 4.0, "mean abs error {err}");}++// ------------------------------------------------------------------------------------------ M4.4 Upright++use crate::upright::{Segment, detect_segments, solve_guided};+use lightcraft_develop::Upright;++#[test]+fn segment_detector_finds_known_lines() {+ // three dark lines at known angles on a light background+ let lines = [+ (Point::new(60.0, 40.0), Point::new(80.0, 280.0)),+ (Point::new(120.0, 300.0), Point::new(420.0, 260.0)),+ (Point::new(300.0, 30.0), Point::new(440.0, 200.0)),+ ];+ let dist = |p: Point, a: Point, b: Point| {+ let ab = b - a;+ let t = ((p - a).dot(ab) / ab.dot(ab)).clamp(0.0, 1.0);+ p.dist(a + ab * t)+ };+ let lum = lightcraft_raster::Plane::from_fn(480, 320, |x, y| {+ let p = Point::new(x as f64 + 0.5, y as f64 + 0.5);+ let d = lines.iter().map(|(a, b)| dist(p, *a, *b)).fold(f64::MAX, f64::min);+ (0.15 + 0.7 * ((d - 1.0) / 1.2).clamp(0.0, 1.0)) as f32+ });+ let segs = detect_segments(&lum);+ let l = 240.0;+ for (a, b) in lines {+ let want = (b.y - a.y).atan2(b.x - a.x);+ let len = a.dist(b) / l;+ let hit = segs.iter().any(|s| {+ let got = (s.b.y - s.a.y).atan2(s.b.x - s.a.x);+ let mut d = (got - want).abs() % std::f64::consts::PI;+ if d > std::f64::consts::FRAC_PI_2 {+ d = std::f64::consts::PI - d;+ }+ d.to_degrees() < 0.7 && s.len() > 0.6 * len+ });+ assert!(hit, "line {a:?}–{b:?} not found in {segs:?}");+ }+}++/// x of the same dark vertical line at the top, bottom and middle of the output (tracked from the middle).+fn vertical_line_track(img: &Rgba8, x0: f64) -> Vec<f64> {+ let mid = line_x(img, img.height / 2 + 7, x0, 14.0);+ [img.height / 6 + 7, img.height * 5 / 6 - 7].iter().map(|&y| line_x(img, y, mid, 10.0)).chain([mid]).collect()+}++fn horizontal_line_track(img: &Rgba8, y0: f64) -> Vec<f64> {+ let mid = line_y(img, img.width / 2 + 7, y0, 14.0);+ [img.width / 6 + 7, img.width * 5 / 6 - 7].iter().map(|&x| line_y(img, x, mid, 10.0)).chain([mid]).collect()+}++fn upright_render(src: &Rgb32f, mode: Upright) -> Rgba8 {+ let mut s = DevelopSettings::default();+ s.geometry.upright = mode;+ s.geometry.upright_transform = Some(crate::upright::auto_transform(src, &SourceInfo::default(), &s, mode));+ render(src, &SourceInfo::default(), &s, &RenderRequest::fit(src.width, src.height)).image+}++#[test]+fn upright_vertical_fixes_converging_verticals() {+ let (w, h) = (720usize, 480usize);+ // "shot from below" and slightly rolled: the inverse of what the correction should do+ let shot = lightcraft_develop::Geometry { vertical: 35.0, rotate: -2.0, ..Default::default() };+ let src = keystoned_grid(w, h, crate::transform::manual(&shot), 48.0);+ let raw = render(&src, &SourceInfo::default(), &DevelopSettings::default(), &RenderRequest::fit(w, h)).image;+ let before = vertical_line_track(&raw, 130.0);+ assert!(spread(&before) > 6.0, "source verticals converge: {before:?}");+ for mode in [Upright::Vertical, Upright::Auto, Upright::Full] {+ let img = upright_render(&src, mode);+ for x0 in [130.0, 360.0, 590.0] {+ let t = vertical_line_track(&img, x0);+ assert!(spread(&t) < 1.2, "{mode:?}: line near {x0} at {t:?}");+ }+ let t = horizontal_line_track(&img, 240.0);+ assert!(spread(&t) < 1.5, "{mode:?}: horizontals stay level: {t:?}");+ }+}++#[test]+fn upright_level_straightens_a_tilted_horizon() {+ let (w, h) = (720usize, 480usize);+ let shot = lightcraft_develop::Geometry { rotate: 3.5, ..Default::default() };+ let src = keystoned_grid(w, h, crate::transform::manual(&shot), 48.0);+ let img = upright_render(&src, Upright::Level);+ for y0 in [120.0, 240.0, 360.0] {+ let t = horizontal_line_track(&img, y0);+ assert!(spread(&t) < 1.2, "line near {y0} at {t:?}");+ }+}++#[test]+fn upright_full_fixes_both_families() {+ let (w, h) = (720usize, 480usize);+ let shot = lightcraft_develop::Geometry { vertical: 25.0, horizontal: -25.0, ..Default::default() };+ let src = keystoned_grid(w, h, crate::transform::manual(&shot), 48.0);+ let img = upright_render(&src, Upright::Full);+ for x0 in [200.0, 360.0, 520.0] {+ let t = vertical_line_track(&img, x0);+ assert!(spread(&t) < 1.5, "vertical near {x0}: {t:?}");+ }+ for y0 in [150.0, 330.0] {+ let t = horizontal_line_track(&img, y0);+ assert!(spread(&t) < 1.5, "horizontal near {y0}: {t:?}");+ }+}++#[test]+fn guided_upright_from_two_vertical_guides() {+ let (w, h) = (720usize, 480usize);+ let shot = lightcraft_develop::Geometry { vertical: 30.0, ..Default::default() };+ let fwd = crate::transform::manual(&shot);+ let src = keystoned_grid(w, h, fwd, 48.0);+ // guides drawn along two building edges: straight lines of the "true" image, seen through fwd⁻¹+ let inv = fwd.inverse().unwrap();+ let l = 360.0;+ let norm = |p: Point| {+ let q = inv.apply(p);+ Point::new((q.x * l + 360.0) / 720.0, (q.y * l + 240.0) / 480.0)+ };+ let mut s = DevelopSettings::default();+ s.geometry.upright = Upright::Guided;+ s.geometry.guides =+ vec![(norm(Point::new(-0.5, -0.5)), norm(Point::new(-0.5, 0.5))), (norm(Point::new(0.55, -0.4)), norm(Point::new(0.55, 0.5)))];+ let img = render(&src, &SourceInfo::default(), &s, &RenderRequest::fit(w, h)).image;+ for x0 in [180.0, 360.0, 540.0] {+ let t = vertical_line_track(&img, x0);+ assert!(spread(&t) < 1.2, "guided: line near {x0} at {t:?}");+ }+ // a single guide only levels (rotation): it becomes vertical+ let one = solve_guided(&[Segment { a: Point::new(0.1, -0.5), b: Point::new(0.12, 0.5) }]);+ let p = one.apply(Point::new(0.1, -0.5));+ let q = one.apply(Point::new(0.12, 0.5));+ assert!((p.x - q.x).abs() < 1e-9, "single vertical guide becomes vertical: {p:?} {q:?}");+}++#[test]+fn upright_analysis_is_resolution_independent() {+ let shot = lightcraft_develop::Geometry { vertical: 30.0, rotate: 1.5, ..Default::default() };+ let fwd = crate::transform::manual(&shot);+ let big = keystoned_grid(1200, 800, fwd, 80.0);+ let small = keystoned_grid(600, 400, fwd, 40.0);+ let s = DevelopSettings::default();+ let a = crate::upright::auto_transform(&big, &SourceInfo::default(), &s, Upright::Vertical);+ let b = crate::upright::auto_transform(&small, &SourceInfo::default(), &s, Upright::Vertical);+ for p in [Point::new(-1.0, -0.66), Point::new(1.0, -0.66), Point::new(1.0, 0.66), Point::new(-1.0, 0.66)] {+ assert!(a.apply(p).dist(b.apply(p)) < 0.006, "{:?} vs {:?}", a.apply(p), b.apply(p));+ }+ // a setting that names the mode without a stored transform renders like the stored one+ let mut s1 = DevelopSettings::default();+ s1.geometry.upright = Upright::Vertical;+ let lazy = render(&small, &SourceInfo::default(), &s1, &RenderRequest::fit(300, 300)).image;+ s1.geometry.upright_transform = Some(b);+ let stored = render(&small, &SourceInfo::default(), &s1, &RenderRequest::fit(300, 300)).image;+ assert_eq!(lazy.data, stored.data);+}diff --git a/crates/pipeline/src/upright.rs b/crates/pipeline/src/upright.rsnew file mode 100644index 000000000..b7e93bc94--- /dev/null+++ b/crates/pipeline/src/upright.rs@@ -0,0 +1,570 @@+//! Upright: automatic perspective correction.+//!+//! 1. **Line segments** — our own gradient-based detector: pixels with a strong luminance gradient are grown into+//! regions of consistent level-line orientation (seeded from the strongest gradients), and each elongated region+//! is fitted with a segment (weighted principal axis).+//! 2. **Vanishing points** — near-vertical and near-horizontal segments are grouped; for each family a RANSAC over+//! segment pairs finds the point (possibly at infinity) most segments point at, refined by weighted least squares+//! (smallest eigenvector of `Σ w·l·lᵀ` over the inlier lines).+//! 3. **Correction** — a virtual camera rotation `K·R·K⁻¹` that sends the vertical vanishing direction to the image+//! y axis (and, for Full, the horizontal one to the x axis, with the focal length estimated from their+//! orthogonality when possible); Level is a pure rotation.+//!+//! Guided Upright solves the same problem from up to four user-drawn guides.+//!+//! Coordinates: centred, `(p − centre) / (long edge / 2)` of the lens-corrected image, so results are independent+//! of the analysis resolution. Results map lens-corrected → transformed coordinates.++use std::borrow::Cow;+use std::sync::Mutex;++use lightcraft_develop::{Crop, DevelopSettings, Geometry, Upright};+use lightcraft_geom::{Homography, Point};+use lightcraft_raster::{Plane, Rgb32f};++use crate::SourceInfo;++use crate::transform::{DEFAULT_FOCAL, Mat3, recentre, rotation_homography};++/// A detected (or user-drawn) line segment in centred coordinates.+#[derive(Clone, Copy, Debug, PartialEq)]+pub struct Segment {+ pub a: Point,+ pub b: Point,+}++impl Segment {+ pub fn len(&self) -> f64 {+ self.a.dist(self.b)+ }+ pub fn is_empty(&self) -> bool {+ self.len() == 0.0+ }+ fn mid(&self) -> Point {+ self.a.lerp(self.b, 0.5)+ }+ /// Homogeneous line through the endpoints, normalized so (a, b) is a unit normal.+ fn line(&self) -> [f64; 3] {+ let l = cross([self.a.x, self.a.y, 1.0], [self.b.x, self.b.y, 1.0]);+ let n = l[0].hypot(l[1]).max(1e-12);+ [l[0] / n, l[1] / n, l[2] / n]+ }+ /// Angle from vertical in degrees (0 = vertical), folded to 0..90.+ fn tilt_from_vertical(&self) -> f64 {+ let (dx, dy) = (self.b.x - self.a.x, self.b.y - self.a.y);+ dx.abs().atan2(dy.abs()).to_degrees()+ }+}++fn cross(a: [f64; 3], b: [f64; 3]) -> [f64; 3] {+ [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]+}++fn dot(a: [f64; 3], b: [f64; 3]) -> f64 {+ a[0] * b[0] + a[1] * b[1] + a[2] * b[2]+}++fn norm(a: [f64; 3]) -> [f64; 3] {+ let n = dot(a, a).sqrt().max(1e-300);+ [a[0] / n, a[1] / n, a[2] / n]+}++// ------------------------------------------------------------------------------------------ segments++/// Detect line segments in a luminance plane (any scale; values roughly 0..1, perceptual). Returns segments in+/// centred coordinates of the plane.+pub fn detect_segments(lum: &Plane) -> Vec<Segment> {+ let (w, h) = (lum.width, lum.height);+ if w < 16 || h < 16 {+ return Vec::new();+ }+ let img = lightcraft_raster::blur::gaussian(lum, 0.8);+ let at = |x: usize, y: usize| img.data[y * w + x];+ let n = w * h;+ let mut mag = vec![0.0f32; n];+ let mut ang = vec![0.0f32; n]; // level-line angle (gradient + 90°), radians, mod π+ for y in 1..h - 1 {+ for x in 1..w - 1 {+ let gx = (at(x + 1, y - 1) + 2.0 * at(x + 1, y) + at(x + 1, y + 1)) - (at(x - 1, y - 1) + 2.0 * at(x - 1, y) + at(x - 1, y + 1));+ let gy = (at(x - 1, y + 1) + 2.0 * at(x, y + 1) + at(x + 1, y + 1)) - (at(x - 1, y - 1) + 2.0 * at(x, y - 1) + at(x + 1, y - 1));+ let m = gx.hypot(gy) / 8.0;+ mag[y * w + x] = m;+ ang[y * w + x] = (gy.atan2(gx) + std::f32::consts::FRAC_PI_2).rem_euclid(std::f32::consts::PI);+ }+ }+ // adaptive threshold: strong edges relative to the image's own contrast+ let mut sorted: Vec<f32> = mag.iter().copied().filter(|m| *m > 1e-4).collect();+ if sorted.len() < 32 {+ return Vec::new();+ }+ sorted.sort_by(f32::total_cmp);+ let p90 = sorted[sorted.len() * 9 / 10];+ let thr = (p90 * 0.35).max(0.008);+ let mut order: Vec<u32> = (0..n as u32).filter(|&i| mag[i as usize] > thr).collect();+ order.sort_by(|&a, &b| mag[b as usize].total_cmp(&mag[a as usize]));+ let mut used = vec![false; n];+ let tol = 22.5f32.to_radians();+ let min_len = 0.04 * w.max(h) as f64;+ let half_long = w.max(h) as f64 / 2.0;+ let (cx, cy) = (w as f64 / 2.0, h as f64 / 2.0);+ let mut out = Vec::new();+ let mut stack: Vec<usize> = Vec::new();+ let mut region: Vec<usize> = Vec::new();+ for &seed in &order {+ let seed = seed as usize;+ if used[seed] {+ continue;+ }+ used[seed] = true;+ region.clear();+ region.push(seed);+ stack.clear();+ stack.push(seed);+ // region angle via doubled-angle mean+ let (mut sc, mut ss) = ((2.0 * ang[seed]).cos(), (2.0 * ang[seed]).sin());+ while let Some(i) = stack.pop() {+ let (x, y) = (i % w, i / w);+ let ra = ss.atan2(sc) / 2.0;+ for dy in -1i32..=1 {+ for dx in -1i32..=1 {+ if dx == 0 && dy == 0 {+ continue;+ }+ let (nx, ny) = (x as i32 + dx, y as i32 + dy);+ if nx < 1 || ny < 1 || nx >= w as i32 - 1 || ny >= h as i32 - 1 {+ continue;+ }+ let j = ny as usize * w + nx as usize;+ if used[j] || mag[j] <= thr {+ continue;+ }+ let mut d = (ang[j] - ra).abs() % std::f32::consts::PI;+ if d > std::f32::consts::FRAC_PI_2 {+ d = std::f32::consts::PI - d;+ }+ if d > tol {+ continue;+ }+ used[j] = true;+ region.push(j);+ stack.push(j);+ sc += (2.0 * ang[j]).cos();+ ss += (2.0 * ang[j]).sin();+ }+ }+ }+ if region.len() < 12 {+ continue;+ }+ // weighted principal axis+ let (mut sw, mut mx, mut my) = (0.0f64, 0.0f64, 0.0f64);+ for &i in ®ion {+ let wt = mag[i] as f64;+ sw += wt;+ mx += wt * (i % w) as f64;+ my += wt * (i / w) as f64;+ }+ mx /= sw;+ my /= sw;+ let (mut sxx, mut syy, mut sxy) = (0.0, 0.0, 0.0);+ for &i in ®ion {+ let wt = mag[i] as f64;+ let (dx, dy) = ((i % w) as f64 - mx, (i / w) as f64 - my);+ sxx += wt * dx * dx;+ syy += wt * dy * dy;+ sxy += wt * dx * dy;+ }+ let theta = 0.5 * (2.0 * sxy).atan2(sxx - syy);+ let (ux, uy) = (theta.cos(), theta.sin());+ let (mut lo, mut hi, mut wlo, mut whi) = (f64::MAX, f64::MIN, f64::MAX, f64::MIN);+ for &i in ®ion {+ let (dx, dy) = ((i % w) as f64 - mx, (i / w) as f64 - my);+ let t = dx * ux + dy * uy;+ let s = -dx * uy + dy * ux;+ lo = lo.min(t);+ hi = hi.max(t);+ wlo = wlo.min(s);+ whi = whi.max(s);+ }+ let (len, width) = (hi - lo, (whi - wlo).max(1.0));+ if len < min_len || len / width < 5.0 {+ continue;+ }+ let a = Point::new((mx + 0.5 + ux * lo - cx) / half_long, (my + 0.5 + uy * lo - cy) / half_long);+ let b = Point::new((mx + 0.5 + ux * hi - cx) / half_long, (my + 0.5 + uy * hi - cy) / half_long);+ out.push(Segment { a, b });+ }+ out+}++// ------------------------------------------------------------------------------------------ vanishing points++/// Angular error (radians) between a segment and the direction from its midpoint to the (homogeneous) point `v`.+fn vp_error(s: &Segment, v: [f64; 3]) -> f64 {+ let m = s.mid();+ let (dx, dy) = (v[0] - m.x * v[2], v[1] - m.y * v[2]);+ let (sx, sy) = (s.b.x - s.a.x, s.b.y - s.a.y);+ let d = dx.hypot(dy);+ if d < 1e-12 {+ return 0.0;+ }+ let c = ((dx * sx + dy * sy) / (d * sx.hypot(sy).max(1e-12))).abs().min(1.0);+ c.acos()+}++/// Smallest eigenvector of a symmetric 3×3 matrix (Jacobi rotations).+fn smallest_eigvec(m: Mat3) -> [f64; 3] {+ let mut a = m;+ let mut v = [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];+ for _ in 0..50 {+ let (mut p, mut q, mut big) = (0, 1, 0.0);+ for i in 0..3 {+ for j in i + 1..3 {+ if a[i][j].abs() > big {+ big = a[i][j].abs();+ p = i;+ q = j;+ }+ }+ }+ if big < 1e-15 {+ break;+ }+ let theta = (a[q][q] - a[p][p]) / (2.0 * a[p][q]);+ let t = theta.signum() / (theta.abs() + (theta * theta + 1.0).sqrt());+ let t = if theta == 0.0 { 1.0 } else { t };+ let c = 1.0 / (t * t + 1.0).sqrt();+ let s = t * c;+ for k in 0..3 {+ let (akp, akq) = (a[k][p], a[k][q]);+ a[k][p] = c * akp - s * akq;+ a[k][q] = s * akp + c * akq;+ }+ for k in 0..3 {+ let (apk, aqk) = (a[p][k], a[q][k]);+ a[p][k] = c * apk - s * aqk;+ a[q][k] = s * apk + c * aqk;+ }+ for row in v.iter_mut() {+ let (vp, vq) = (row[p], row[q]);+ row[p] = c * vp - s * vq;+ row[q] = s * vp + c * vq;+ }+ }+ let i = (0..3).min_by(|&i, &j| a[i][i].total_cmp(&a[j][j])).unwrap_or(0);+ norm([v[0][i], v[1][i], v[2][i]])+}++/// Least-squares vanishing point of `segs` (weights = lengths).+fn refine_vp(segs: &[&Segment]) -> [f64; 3] {+ let mut m = [[0.0; 3]; 3];+ for s in segs {+ let l = s.line();+ let w = s.len();+ for i in 0..3 {+ for j in 0..3 {+ m[i][j] += w * l[i] * l[j];+ }+ }+ }+ smallest_eigvec(m)+}++/// The dominant vanishing point of a segment family: RANSAC over pairs, then least squares on the inliers.+/// Returns the point and the total inlier length, or None with fewer than two consistent segments.+pub fn vanishing_point(segs: &[Segment]) -> Option<([f64; 3], f64)> {+ if segs.len() < 2 {+ return None;+ }+ let thr = 1.5f64.to_radians();+ let score = |v: [f64; 3]| -> f64 { segs.iter().map(|s| if vp_error(s, v) < thr { s.len() } else { 0.0 }).sum() };+ // deterministic pair sampling, longest segments first+ let mut idx: Vec<usize> = (0..segs.len()).collect();+ idx.sort_by(|&a, &b| segs[b].len().total_cmp(&segs[a].len()));+ idx.truncate(60);+ let mut best: Option<([f64; 3], f64)> = None;+ for (k, &i) in idx.iter().enumerate() {+ for &j in &idx[k + 1..] {+ let v = cross(segs[i].line(), segs[j].line());+ if dot(v, v) < 1e-24 {+ continue;+ }+ let v = norm(v);+ let sc = score(v);+ if best.is_none_or(|b| sc > b.1) {+ best = Some((v, sc));+ }+ }+ }+ let (v, _) = best?;+ let inl: Vec<&Segment> = segs.iter().filter(|s| vp_error(s, v) < thr * 2.0).collect();+ if inl.len() < 2 {+ return None;+ }+ let v = refine_vp(&inl);+ let total: f64 = segs.iter().filter(|s| vp_error(s, v) < thr * 2.0).map(|s| s.len()).sum();+ let count = segs.iter().filter(|s| vp_error(s, v) < thr * 2.0).count();+ (count >= 2).then_some((v, total))+}++// ------------------------------------------------------------------------------------------ solving++/// Direction (camera frame) of a vanishing point for focal length `f`.+fn direction(v: [f64; 3], f: f64) -> [f64; 3] {+ norm([v[0] / f, v[1] / f, v[2]])+}++/// The rotation (rows) taking unit vector `a` to unit vector `b` (Rodrigues; minimal angle).+fn rotation_between(a: [f64; 3], b: [f64; 3]) -> Mat3 {+ let axis = cross(a, b);+ let s = dot(axis, axis).sqrt();+ let c = dot(a, b);+ if s < 1e-12 {+ return [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]];+ }+ let k = [axis[0] / s, axis[1] / s, axis[2] / s];+ let kx = [[0.0, -k[2], k[1]], [k[2], 0.0, -k[0]], [-k[1], k[0], 0.0]];+ let mut r = [[0.0; 3]; 3];+ for i in 0..3 {+ for j in 0..3 {+ let kk: f64 = (0..3).map(|m| kx[i][m] * kx[m][j]).sum();+ r[i][j] = if i == j { 1.0 } else { 0.0 } + s * kx[i][j] + (1.0 - c) * kk;+ }+ }+ r+}++fn rotation_angle(r: &Mat3) -> f64 {+ ((r[0][0] + r[1][1] + r[2][2] - 1.0) / 2.0).clamp(-1.0, 1.0).acos()+}++/// Vertical correction: send the vertical vanishing direction to the image y axis.+fn solve_vertical(v: [f64; 3], f: f64) -> Mat3 {+ let mut d = direction(v, f);+ if d[1] < 0.0 {+ d = [-d[0], -d[1], -d[2]];+ }+ rotation_between(d, [0.0, 1.0, 0.0])+}++/// Full correction: vertical direction → y, horizontal direction → x (Gram–Schmidt).+fn solve_full(v: [f64; 3], hz: [f64; 3], f: f64) -> Mat3 {+ let mut dv = direction(v, f);+ if dv[1] < 0.0 {+ dv = [-dv[0], -dv[1], -dv[2]];+ }+ let mut dh = direction(hz, f);+ if dh[0] < 0.0 {+ dh = [-dh[0], -dh[1], -dh[2]];+ }+ let p = dot(dh, dv);+ let r1 = norm([dh[0] - p * dv[0], dh[1] - p * dv[1], dh[2] - p * dv[2]]);+ let r3 = cross(r1, dv);+ [r1, dv, r3]+}++/// Focal length (centred units) that makes two finite vanishing points orthogonal, when plausible.+fn focal_from_vps(v: [f64; 3], h: [f64; 3]) -> Option<f64> {+ if v[2].abs() < 1e-9 || h[2].abs() < 1e-9 {+ return None;+ }+ let (vx, vy, hx, hy) = (v[0] / v[2], v[1] / v[2], h[0] / h[2], h[1] / h[2]);+ let f2 = -(vx * hx + vy * hy);+ (f2 > 0.0).then(|| f2.sqrt()).filter(|f| (0.5..=6.0).contains(f))+}++/// Pure rotation (degrees, clockwise +) that levels the dominant lines.+fn level_angle(vert: &[Segment], horiz: &[Segment]) -> Option<f64> {+ let dev = |s: &Segment, vertical: bool| {+ let (dx, dy) = (s.b.x - s.a.x, s.b.y - s.a.y);+ // signed deviation in degrees of the segment from the axis+ let a = if vertical { dx.atan2(dy) } else { dy.atan2(dx) };+ let a = a.to_degrees();+ let a = if a > 90.0 {+ a - 180.0+ } else if a < -90.0 {+ a + 180.0+ } else {+ a+ };+ if vertical { -a } else { a }+ };+ let lh: f64 = horiz.iter().map(Segment::len).sum();+ let lv: f64 = vert.iter().map(Segment::len).sum();+ let (set, vertical) = if lh >= lv * 0.5 && lh > 0.0 { (horiz, false) } else { (vert, true) };+ if set.is_empty() {+ return None;+ }+ // length-weighted median+ let mut v: Vec<(f64, f64)> = set.iter().map(|s| (dev(s, vertical), s.len())).collect();+ v.sort_by(|a, b| a.0.total_cmp(&b.0));+ let total: f64 = v.iter().map(|x| x.1).sum();+ let mut acc = 0.0;+ for (d, l) in &v {+ acc += l;+ if acc >= total / 2.0 {+ return Some(-*d);+ }+ }+ None+}++fn rot_z_h(deg: f64) -> Homography {+ let (s, c) = deg.to_radians().sin_cos();+ Homography([c, -s, 0.0, s, c, 0.0, 0.0, 0.0, 1.0])+}++/// What an Upright analysis found.+#[derive(Clone, Debug, Default)]+pub struct Analysis {+ pub vertical: Vec<Segment>,+ pub horizontal: Vec<Segment>,+ pub vertical_vp: Option<[f64; 3]>,+ pub horizontal_vp: Option<[f64; 3]>,+}++/// Group segments into near-vertical / near-horizontal families and find their vanishing points.+pub fn analyze(segs: &[Segment]) -> Analysis {+ let vertical: Vec<Segment> = segs.iter().copied().filter(|s| s.tilt_from_vertical() < 30.0).collect();+ let horizontal: Vec<Segment> = segs.iter().copied().filter(|s| s.tilt_from_vertical() > 60.0).collect();+ let vertical_vp = vanishing_point(&vertical).map(|v| v.0);+ let horizontal_vp = vanishing_point(&horizontal).map(|v| v.0);+ Analysis { vertical, horizontal, vertical_vp, horizontal_vp }+}++/// The Upright correction for `mode` from an analysis (lens-corrected → transformed, centred coordinates).+pub fn solve(mode: Upright, a: &Analysis) -> Homography {+ let level = || level_angle(&a.vertical, &a.horizontal).map(rot_z_h).unwrap_or(Homography::IDENTITY);+ let vertical = || a.vertical_vp.map(|v| solve_vertical(v, DEFAULT_FOCAL));+ let full = || {+ let (v, h) = (a.vertical_vp?, a.horizontal_vp?);+ let f = focal_from_vps(v, h).unwrap_or(DEFAULT_FOCAL);+ Some((solve_full(v, h, f), f))+ };+ match mode {+ Upright::Off | Upright::Guided => Homography::IDENTITY,+ Upright::Level => level(),+ Upright::Vertical => vertical().map(|r| recentre(&rotation_homography(&r, DEFAULT_FOCAL))).unwrap_or_else(level),+ Upright::Full => match full() {+ Some((r, f)) => recentre(&rotation_homography(&r, f)),+ None => vertical().map(|r| recentre(&rotation_homography(&r, DEFAULT_FOCAL))).unwrap_or_else(level),+ },+ Upright::Auto => {+ // balanced: full correction only when it is moderate, else vertical, else level+ if let Some((r, f)) = full().filter(|(r, _)| rotation_angle(r) < 20f64.to_radians()) {+ return recentre(&rotation_homography(&r, f));+ }+ match vertical().filter(|r| rotation_angle(r) < 25f64.to_radians()) {+ Some(r) => recentre(&rotation_homography(&r, DEFAULT_FOCAL)),+ None => level(),+ }+ }+ }+}++/// Guided Upright from user guides (centred coordinates of the lens-corrected image). Guides closer to vertical+/// define the vertical vanishing point, the others the horizontal one; one guide of a kind only levels.+pub fn solve_guided(guides: &[Segment]) -> Homography {+ let guides: Vec<Segment> = guides.iter().copied().filter(|g| g.len() > 1e-6).take(4).collect();+ let vert: Vec<Segment> = guides.iter().copied().filter(|g| g.tilt_from_vertical() <= 45.0).collect();+ let horiz: Vec<Segment> = guides.iter().copied().filter(|g| g.tilt_from_vertical() > 45.0).collect();+ let vp = |s: &[Segment]| -> Option<[f64; 3]> {+ if s.len() < 2 {+ return None;+ }+ let refs: Vec<&Segment> = s.iter().collect();+ Some(refine_vp(&refs))+ };+ let (v, h) = (vp(&vert), vp(&horiz));+ match (v, h) {+ (Some(v), Some(h)) => {+ let f = focal_from_vps(v, h).unwrap_or(DEFAULT_FOCAL);+ recentre(&rotation_homography(&solve_full(v, h, f), f))+ }+ (Some(v), None) => recentre(&rotation_homography(&solve_vertical(v, DEFAULT_FOCAL), DEFAULT_FOCAL)),+ (None, Some(_)) => {+ // two horizontal guides: make them parallel and horizontal (rotate the problem by 90°)+ let swap = |p: Point| Point::new(p.y, -p.x);+ let hs: Vec<Segment> = horiz.iter().map(|s| Segment { a: swap(s.a), b: swap(s.b) }).collect();+ let refs: Vec<&Segment> = hs.iter().collect();+ let r = solve_vertical(refine_vp(&refs), DEFAULT_FOCAL);+ let inner = rotation_homography(&r, DEFAULT_FOCAL);+ let to = Homography([0.0, 1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0, 1.0]); // (x, y) → (y, −x)+ let back = to.inverse().unwrap_or(Homography::IDENTITY);+ recentre(&back.mul(&inner).mul(&to))+ }+ (None, None) => level_angle(&vert, &horiz).map(rot_z_h).unwrap_or(Homography::IDENTITY),+ }+}++// ------------------------------------------------------------------------------------------ sources++/// Long edge of the analysis image.+const ANALYSIS_LONG: usize = 1024;++/// Analyse a source: the lens-corrected (optics applied, no perspective/crop) image at [`ANALYSIS_LONG`] px,+/// segment detection and vanishing points. Cached per source + optics settings.+pub fn analyze_source(src: &Rgb32f, info: &SourceInfo, s: &DevelopSettings) -> Analysis {+ static CACHE: Mutex<Vec<(u64, Analysis)>> = Mutex::new(Vec::new());+ let mut base = s.clone();+ base.geometry = Geometry::default();+ base.crop = Crop::default();+ let key = crate::optics::fingerprint(src)+ ^ lightcraft_develop::DevelopSettings { optics: s.optics, orientation: s.orientation, ..Default::default() }.hash64().rotate_left(17);+ if let Ok(c) = CACHE.lock()+ && let Some((_, a)) = c.iter().find(|(k, _)| *k == key)+ {+ return a.clone();+ }+ let frame = crate::frame_for(src, info, &base, false);+ let (w, h) = frame.fit(ANALYSIS_LONG, ANALYSIS_LONG);+ let img = frame.sample(src, w, h);+ // perceptual lightness, normalized to the image's bright end+ let lum = img.luminance();+ let mut v: Vec<f32> = lum.data.iter().copied().filter(|x| x.is_finite()).collect();+ v.sort_by(f32::total_cmp);+ let white = v.get(v.len() * 99 / 100).copied().unwrap_or(1.0).max(1e-4);+ let lum = lum.map(|x| (x.max(0.0) / white).min(1.5).powf(1.0 / 2.4));+ let a = analyze(&detect_segments(&lum));+ if let Ok(mut c) = CACHE.lock() {+ c.push((key, a.clone()));+ if c.len() > 8 {+ c.remove(0);+ }+ }+ a+}++/// The automatic Upright correction for `mode` on `src` (identity for Off and Guided).+pub fn auto_transform(src: &Rgb32f, info: &SourceInfo, s: &DevelopSettings, mode: Upright) -> Homography {+ if matches!(mode, Upright::Off | Upright::Guided) {+ return Homography::IDENTITY;+ }+ solve(mode, &analyze_source(src, info, s))+}++/// Fill in a missing automatic Upright transform (settings from XMP/CLI that name a mode but carry no analysis).+pub fn resolve<'a>(src: &Rgb32f, info: &SourceInfo, s: &'a DevelopSettings) -> Cow<'a, DevelopSettings> {+ let g = &s.geometry;+ if matches!(g.upright, Upright::Off | Upright::Guided) || g.upright_transform.is_some() || !s.section_enabled("geometry") {+ return Cow::Borrowed(s);+ }+ let mut e = s.clone();+ e.geometry.upright_transform = Some(auto_transform(src, info, s, g.upright));+ Cow::Owned(e)+}++/// The Upright homography in effect for settings (stored automatic transform, or solved from guides).+/// `ow × oh` is the oriented image size (guides are normalized to it).+pub fn homography(g: &Geometry, ow: f64, oh: f64) -> Homography {+ match g.upright {+ Upright::Off => Homography::IDENTITY,+ Upright::Guided => {+ let l = ow.max(oh) / 2.0;+ let c = |p: Point| Point::new((p.x * ow - ow / 2.0) / l, (p.y * oh - oh / 2.0) / l);+ let segs: Vec<Segment> = g.guides.iter().map(|(a, b)| Segment { a: c(*a), b: c(*b) }).collect();+ solve_guided(&segs)+ }+ _ => g.upright_transform.unwrap_or(Homography::IDENTITY),+ }+}diff --git a/crates/ui-egui/src/panels/detail.rs b/crates/ui-egui/src/panels/detail.rsindex a23dadf90..4a6eb6267 100644--- a/crates/ui-egui/src/panels/detail.rs+++ b/crates/ui-egui/src/panels/detail.rs@@ -17,12 +17,33 @@ use crate::widgets::register;/// An in-progress on-canvas gesture.#[derive(Clone, Debug)]pub enum Gesture {- Brush { points: Vec<Point> },- Spot { points: Vec<Point> },- CropHandle { handle: u8, start: lightcraft_geom::Rect, angle: f64 },- CropRotate { start_angle: f64, a0: f32 },- Pan { start: (f32, f32), at: Pos2 },- MaskHandle { mask: u32, handle: u8 },+ Brush {+ points: Vec<Point>,+ },+ Spot {+ points: Vec<Point>,+ },+ CropHandle {+ handle: u8,+ start: lightcraft_geom::Rect,+ angle: f64,+ },+ CropRotate {+ start_angle: f64,+ a0: f32,+ },+ Pan {+ start: (f32, f32),+ at: Pos2,+ },+ MaskHandle {+ mask: u32,+ handle: u8,+ },+ /// Guided Upright: a guide being drawn from `a` (normalized transformed coordinates).+ Guide {+ a: Point,+ },}/// Screen ↔ normalized-image mapping for the displayed frame.@@ -237,6 +258,10 @@ fn general_interaction(// ------------------------------------------------------------------------ cropfn crop_overlay(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::Response, map: &CanvasMap, frame: &Frame, d: &DevelopSettings, id: PhotoId) {+ if app.ui.tool == "guidedUpright" {+ guided_overlay(app, ui, resp, map, frame, d);+ return;+ }let quad = frame_crop_quad(d, frame);let pts: Vec<Pos2> = quad.iter().map(|q| map.screen(*q)).collect();let p = ui.painter();@@ -366,6 +391,45 @@ fn crop_overlay(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::Responslet _ = id;}+/// Guided Upright: draw up to four guides along lines that should be vertical or horizontal. Guides are+/// stored in lens-corrected (pre-perspective) coordinates, so they stay attached to the image as it warps.+fn guided_overlay(app: &mut LightcraftApp, ui: &mut egui::Ui, resp: &egui::Response, map: &CanvasMap, frame: &Frame, d: &DevelopSettings) {+ let p = ui.painter_at(map.rect.expand(8.0));+ let col = Color32::from_rgb(255, 196, 40);+ let draw = |a: Pos2, b: Pos2| {+ p.line_segment([a, b], Stroke::new(3.0, Color32::from_black_alpha(120)));+ p.line_segment([a, b], Stroke::new(1.5, col));+ for q in [a, b] {+ p.circle_filled(q, 4.0, col);+ p.circle_stroke(q, 4.0, Stroke::new(1.0, Color32::BLACK));+ }+ };+ for (i, (a, b)) in d.geometry.guides.iter().enumerate() {+ let (sa, sb) = (map.screen(frame.corrected_to_transformed(*a)), map.screen(frame.corrected_to_transformed(*b)));+ register(ui.ctx(), format!("uprightGuide:{i}"), Rect::from_two_pos(sa, sb));+ draw(sa, sb);+ }+ ui.ctx().set_cursor_icon(egui::CursorIcon::Crosshair);+ if resp.drag_started()+ && let Some(q) = resp.interact_pointer_pos()+ {+ app.gesture = Some(Gesture::Guide { a: map.norm(q) });+ }+ if let (Some(Gesture::Guide { a }), Some(q)) = (&app.gesture, resp.interact_pointer_pos()) {+ draw(map.screen(*a), q);+ }+ if resp.drag_stopped()+ && let (Some(Gesture::Guide { a }), Some(q)) = (app.gesture.clone(), resp.interact_pointer_pos())+ {+ app.gesture = None;+ let b = map.norm(q);+ if a.dist(b) > 0.02 {+ let (ca, cb) = (frame.transformed_to_corrected(a), frame.transformed_to_corrected(b));+ let _ = app.run("geometry.guides", json!({"guides": [[ca.x, ca.y, cb.x, cb.y]], "add": true}));+ }+ }+}+/// Normalized oriented coords → the straightened (rotated) frame the crop rect lives in.fn to_straight(n: Point, angle: f64, frame: &Frame) -> Point {let (w, h) = (frame.ow, frame.oh);diff --git a/crates/ui-egui/src/panels/right.rs b/crates/ui-egui/src/panels/right.rsindex 37ea4ef5c..d112c8b3c 100644--- a/crates/ui-egui/src/panels/right.rs+++ b/crates/ui-egui/src/panels/right.rs@@ -134,6 +134,47 @@ fn crop(app: &mut LightcraftApp, ui: &mut egui::Ui, id: PhotoId) {divider(ui);header(ui, "Geometry");padded(ui, |ui| {+ ui.label("Upright");+ ui.horizontal_wrapped(|ui| {+ use lightcraft_develop::Upright;+ for (label, mode, key) in [+ ("Off", Upright::Off, "off"),+ ("Auto", Upright::Auto, "auto"),+ ("Guided", Upright::Guided, "guided"),+ ("Level", Upright::Level, "level"),+ ("Vertical", Upright::Vertical, "vertical"),+ ("Full", Upright::Full, "full"),+ ] {+ if text_button(ui, &format!("upright-{key}"), label, d.geometry.upright == mode).clicked() {+ let _ = app.run("geometry.upright", json!({"mode": key}));+ app.ui.tool = if mode == Upright::Guided { "guidedUpright".into() } else { String::new() };+ }+ }+ });+ let guided = d.geometry.upright == lightcraft_develop::Upright::Guided;+ ui.horizontal_wrapped(|ui| {+ if !guided && d.geometry.upright != lightcraft_develop::Upright::Off && text_button(ui, "uprightUpdate", "Update", false).clicked() {+ let mode = serde_json::to_value(d.geometry.upright).unwrap_or_default();+ let _ = app.run("geometry.upright", json!({"mode": mode}));+ }+ if guided {+ let drawing = app.ui.tool == "guidedUpright";+ if text_button(ui, "uprightDraw", "Draw Guides", drawing).clicked() {+ app.ui.tool = if drawing { String::new() } else { "guidedUpright".into() };+ }+ if !d.geometry.guides.is_empty() && text_button(ui, "uprightClear", "Clear Guides", false).clicked() {+ let _ = app.run("geometry.guides", json!({"guides": []}));+ }+ }+ });+ if guided {+ ui.label(+ egui::RichText::new(format!("{} of 4 guides — drag along lines that should be vertical or horizontal.", d.geometry.guides.len()))+ .size(11.0)+ .color(Tokens::get(ui.ctx()).text_dim),+ );+ }+ ui.add_space(4.0);let mut c = d.geometry.constrain_crop;if ui.checkbox(&mut c, "Constrain Crop").changed() {let _ = app.run("develop.merge", json!({"settings": {"geometry": {"constrain_crop": c}}, "label": "Constrain Crop"}));