LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
Tone Curve: expose ParametricCurve from pipeline and preserve other regions on drag
Paul5eebb9c2f9ed
diff --git a/crates/pipeline/src/curve.rs b/crates/pipeline/src/curve.rsnew file mode 100644index 000000000..d336274e0--- /dev/null+++ b/crates/pipeline/src/curve.rs@@ -0,0 +1,213 @@+//! The parametric tone curve model shared by the pipeline renderer and the UI curve editor.+//!+//! Lightroom-style tone curve parametric model: four regions (shadows, darks, lights, highlights)+//! separated by three split points. Each region contributes a cosine-windowed bump, summed and+//! forced monotone.++use lightcraft_color::spline::Lut1;+use lightcraft_develop::ToneCurve;++/// The four shape controls of the parametric curve, in graph order: region 0 is the darkest.+pub const PARAM_AMOUNTS: [&str; 4] = ["curve.shadows", "curve.darks", "curve.lights", "curve.highlights"];++/// Resolution the parametric curve is sampled at, matching the renderer's LUT.+pub const PARAM_LUT: usize = 1024;++/// The parametric (region) curve of a [`ToneCurve`]: the four region amounts, each a cosine bump+/// over its window between two splits, summed and then forced monotone.+///+/// This is the renderer's curve, not an approximation of it — both `curve_luts` in the pipeline+/// and the curve editor in the UI use this struct so they can never disagree.+#[derive(Clone, Debug)]+pub struct ParametricCurve {+ /// The curve, sampled and already forced monotone.+ lut: [f32; PARAM_LUT],+ /// The three region boundaries as fractions of the graph (0..1).+ pub splits: [f64; 3],+ /// The four region amounts, in graph order (0 = shadows, 3 = highlights).+ pub amounts: [f64; 4],+}++impl ParametricCurve {+ pub fn new(c: &ToneCurve) -> ParametricCurve {+ let (s0, s1, s2) = ((c.split_shadows / 100.0) as f32, (c.split_mid / 100.0) as f32, (c.split_highlights / 100.0) as f32);+ let (a0, a1, a2, a3) = (c.shadows, c.darks, c.lights, c.highlights);+ let splits = [s0 as f64, s1 as f64, s2 as f64];+ let amounts = [a0, a1, a2, a3];+ let regions = [(0.0, s0, a0), (s0, s1, a1), (s1, s2, a2), (s2, 1.0, a3)];+ let mut lut = [0.0_f32; PARAM_LUT];+ let mut prev = 0.0_f32;+ for (i, entry) in lut.iter_mut().enumerate() {+ let x = i as f32 / (PARAM_LUT - 1) as f32;+ let mut d = 0.0_f32;+ for (a, b, amt) in regions {+ if amt == 0.0 {+ continue;+ }+ let (ctr, half) = ((a + b) / 2.0, (b - a) * 0.75 + 0.05);+ let t = ((x - ctr) / half).clamp(-1.0, 1.0);+ d += (amt / 100.0) as f32 * 0.22 * (0.5 + 0.5 * (t * std::f32::consts::PI).cos());+ }+ let y = (x + d * 4.0 * x * (1.0 - x)).clamp(0.0, 1.0);+ prev = prev.max(y);+ *entry = prev;+ }+ ParametricCurve { lut, splits, amounts }+ }++ /// Convert the evaluated parametric curve into a 1024-entry [`Lut1`].+ pub fn to_lut(&self) -> Lut1 {+ Lut1 { v: self.lut.to_vec() }+ }++ /// The curve at `x` (0 = black, 1 = white), read off the table (so it never overshoots the ends).+ pub fn at(&self, x: f64) -> f64 {+ let x = x.clamp(0.0, 1.0) as f32;+ let at = x * (PARAM_LUT - 1) as f32;+ let i = at.floor().clamp(0.0, (PARAM_LUT - 1) as f32) as usize;+ let cur = self.lut.get(i).copied().unwrap_or(0.0);+ let next = self.lut.get(i + 1).copied().unwrap_or(cur);+ let f = at - i as f32;+ (cur + (next - cur) * f) as f64+ }++ /// Where region `region`'s handle sits on the input axis: the middle of its own window, so a+ /// handle never has to cross a split to be grabbed.+ pub fn region_x(&self, region: usize) -> f64 {+ let (a, b) = self.region_window(region);+ (a + b) / 2.0+ }++ /// The window (two splits, as fractions of the graph) region `region` owns.+ pub fn region_window(&self, region: usize) -> (f64, f64) {+ let s0 = self.split_x(0);+ let s1 = self.split_x(1);+ let s2 = self.split_x(2);+ match region {+ 0 => (0.0, s0),+ 1 => (s0, s1),+ 2 => (s1, s2),+ _ => (s2, 1.0),+ }+ }++ /// The half-width of region `region`'s own bump, as fraction of the graph.+ pub fn region_half(&self, region: usize) -> f64 {+ let (a, b) = self.region_window(region);+ (b - a) * 0.75 + 0.05+ }++ /// The cosine window region `region` applies at `x` (1 at its centre, 0 at the window edges).+ pub fn region_window_at(&self, region: usize, x: f64) -> f64 {+ let ctr = self.region_x(region);+ let half = self.region_half(region);+ if half <= f64::EPSILON {+ return 0.0;+ }+ let t = ((x - ctr) / half).clamp(-1.0, 1.0);+ 0.5 + 0.5 * (t * std::f64::consts::PI).cos()+ }++ /// The region that owns graph position `x`: the one whose own window contains it. The four+ /// windows tile 0..1, so this is always defined and a drag anywhere on the curve moves exactly+ /// one slider — the region under the pointer.+ pub fn region_at(&self, x: f64) -> usize {+ let x = x.clamp(0.0, 1.0);+ let s0 = self.split_x(0);+ let s1 = self.split_x(1);+ let s2 = self.split_x(2);+ if x <= s0 {+ 0+ } else if x <= s1 {+ 1+ } else if x <= s2 {+ 2+ } else {+ 3+ }+ }++ /// How much output level region `region`'s bump gains at `x` per unit of its slider: the bump is+ /// linear in the amount, so this is a constant for a given `x`. A drag converts the pointer's+ /// vertical motion into a slider change through it.+ pub fn level_per_unit(&self, region: usize, x: f64) -> f64 {+ let x = x.clamp(0.0, 1.0);+ 0.22 / 100.0 * self.region_window_at(region, x) * 4.0 * x * (1.0 - x)+ }++ /// The baseline level at `x` from the identity diagonal plus the contributions of all regions+ /// *except* `region`. Used when inverting the model for `region` while holding the other three+ /// regions fixed.+ pub fn base_level_without(&self, region: usize, x: f64) -> f64 {+ let x = x.clamp(0.0, 1.0);+ let mut d = 0.0;+ for i in 0..4 {+ if i == region {+ continue;+ }+ let amt = self.amounts.get(i).copied().unwrap_or(0.0);+ if amt == 0.0 {+ continue;+ }+ d += (amt / 100.0) * 0.22 * self.region_window_at(i, x);+ }+ x + d * 4.0 * x * (1.0 - x)+ }++ /// The curve level region `region` sits at when its slider holds `amount`, at graph position `x`,+ /// holding the other regions fixed at their current settings.+ pub fn handle_level_at(&self, region: usize, amount: f64, x: f64) -> f64 {+ (self.base_level_without(region, x) + amount * self.level_per_unit(region, x)).clamp(0.0, 1.0)+ }++ /// The amount that puts region `region`'s curve at `level` at `x`, with the other three+ /// regions held fixed — the inverse of [`Self::handle_level_at`]. A level the region cannot+ /// reach saturates rather than jumping.+ pub fn amount_at_level(&self, region: usize, level: f64, x: f64) -> f64 {+ let per_unit = self.level_per_unit(region, x);+ if per_unit.abs() <= f64::EPSILON {+ return self.amounts.get(region).copied().unwrap_or(0.0);+ }+ let base = self.base_level_without(region, x);+ ((level.clamp(0.0, 1.0) - base) / per_unit).clamp(-100.0, 100.0).round()+ }++ /// The graph position split `split` (0..3) sits at, 0..1.+ pub fn split_x(&self, split: usize) -> f64 {+ self.splits.get(split).copied().unwrap_or(0.5)+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn horizontal_inversion_at_x_0_51_with_darks_60_preserves_zero_lights() {+ let c = ToneCurve { darks: 60.0, lights: 0.0, ..Default::default() };+ let model = ParametricCurve::new(&c);+ assert_eq!(model.region_at(0.51), 2, "x=0.51 is inside the Lights region");+ let level = model.at(0.51);+ assert!((level - 0.5619).abs() < 0.001, "extracted model at 0.51 is ~0.5619: {level}");+ // With other regions held fixed, inverting at level ~0.5619 must return Lights = 0, NOT 45!+ let lights = model.amount_at_level(2, level, 0.51);+ assert_eq!(lights, 0.0, "zero vertical delta preserves Lights=0: {lights}");+ }++ #[test]+ fn a_curve_level_and_its_amount_are_inverses_with_other_regions_present() {+ let c = ToneCurve { shadows: 20.0, darks: -30.0, lights: 40.0, highlights: -10.0, ..Default::default() };+ let model = ParametricCurve::new(&c);+ for region in 0..4 {+ let centre = model.region_x(region);+ let (_, upper) = model.region_window(region);+ for x in [centre, centre + (upper - centre) * 0.5] {+ for amount in [-100.0, -40.0, 0.0, 30.0, 100.0] {+ let level = model.handle_level_at(region, amount, x);+ let back = model.amount_at_level(region, level, x);+ assert!((back - amount).abs() <= 1.0, "region {region} at {x}: {amount} -> {level} -> {back}");+ }+ }+ }+ }+}diff --git a/crates/pipeline/src/finish.rs b/crates/pipeline/src/finish.rsindex eb65d51a2..ea1736359 100644--- a/crates/pipeline/src/finish.rs+++ b/crates/pipeline/src/finish.rs@@ -29,31 +29,20 @@ fn curve_luts(c: &ToneCurve) -> Option<[Lut1; 3]> {return None;}const N: usize = 1024;- let (s1, s2, s3) = ((c.split_shadows / 100.0) as f32, (c.split_mid / 100.0) as f32, (c.split_highlights / 100.0) as f32);- let regions = [(0.0, s1, c.shadows), (s1, s2, c.darks), (s2, s3, c.lights), (s3, 1.0, c.highlights)];- let mut base = Lut1::from_fn(N, |x| {- let mut d = 0.0;- for (a, b, amt) in regions {- if amt == 0.0 {- continue;- }- let (ctr, half) = ((a + b) / 2.0, (b - a) * 0.75 + 0.05);- let t = ((x - ctr) / half).clamp(-1.0, 1.0);- let win = 0.5 + 0.5 * (t * std::f32::consts::PI).cos();- d += (amt / 100.0) as f32 * 0.22 * win;- }- (x + d * 4.0 * x * (1.0 - x)).clamp(0.0, 1.0)- });- // keep monotone- for i in 1..N {- base.v[i] = base.v[i].max(base.v[i - 1]);- }+ let mut base = crate::curve::ParametricCurve::new(c).to_lut();let to_pts = |p: &[Point]| p.iter().map(|q| (q.x, q.y)).collect::<Vec<_>>();if master {base = MonotoneCurve::new(&to_pts(&c.master)).to_lut(N).compose(&base);}let per = [&c.red, &c.green, &c.blue];- Some(std::array::from_fn(|i| if chans[i] { MonotoneCurve::new(&to_pts(per[i])).to_lut(N).compose(&base) } else { base.clone() }))+ Some(std::array::from_fn(|i| {+ if chans.get(i).copied().unwrap_or(false) {+ let pts = per.get(i).map(|&p| to_pts(p)).unwrap_or_default();+ MonotoneCurve::new(&pts).to_lut(N).compose(&base)+ } else {+ base.clone()+ }+ }))}/// Vignette (post-crop) parameters.diff --git a/crates/pipeline/src/lib.rs b/crates/pipeline/src/lib.rsindex 34df1f8a9..f6b0d995b 100644--- a/crates/pipeline/src/lib.rs+++ b/crates/pipeline/src/lib.rs@@ -27,6 +27,7 @@ pub mod auto;pub mod blemish;pub mod colorops;pub mod cull;+pub mod curve;pub mod dust;pub mod finish;pub mod geometry;@@ -44,6 +45,7 @@ pub mod transform;pub mod upright;pub mod visualize;+pub use curve::{PARAM_AMOUNTS, PARAM_LUT, ParametricCurve};pub use output::{DeepImage, DeepSamples, DisplaySpace, OutputDepth, OutputSpace, OutputTrc, Proof, ProofLut, proof_profile, register_proof_profile};pub use visualize::{MaskView, Overlay};diff --git a/crates/ui-egui/src/panels/edit.rs b/crates/ui-egui/src/panels/edit.rsindex b465c544e..a1b6d362f 100644--- a/crates/ui-egui/src/panels/edit.rs+++ b/crates/ui-egui/src/panels/edit.rs@@ -4,8 +4,9 @@use egui::epaint::{Mesh, Vertex};use egui::{Align2, Color32, Pos2, Rect, RichText, Sense, Stroke, pos2, vec2};use lightcraft_catalog::PhotoId;-use lightcraft_develop::{ControlSpec, DevelopSettings, Section, ToneCurve, Track, WbMode, controls};+use lightcraft_develop::{ControlSpec, DevelopSettings, Section, Track, WbMode, controls};use lightcraft_geom::Point;+use lightcraft_pipeline::{PARAM_AMOUNTS, ParametricCurve};use lightcraft_raster::Histogram;use serde_json::{Value, json};@@ -929,149 +930,9 @@ fn draw_curve_histogram(p: &egui::Painter, r: Rect, h: &lightcraft_raster::Histop.add(mesh);}-/// The four shape controls of the parametric curve, in graph order: region 0 is the darkest.-pub(crate) const PARAM_AMOUNTS: [&str; 4] = ["curve.shadows", "curve.darks", "curve.lights", "curve.highlights"];-/// Resolution the parametric curve is sampled at, matching `lightcraft_pipeline::finish`'s table.-const PARAM_LUT: usize = 1024;/// Segments the graph's curve line is drawn with.pub(crate) const CURVE_SAMPLES: i32 = 96;-/// The parametric (region) curve of a [`ToneCurve`]: the four region amounts, each a cosine bump-/// over its window between two splits, summed and then forced monotone.-///-/// This is the renderer's curve, not an approximation of it — `lightcraft_pipeline::finish::curve_luts`-/// builds the same shape (its own table, whose `x` is the encoded level the curve sees). The graph-/// draws this curve, so the line and the sliders can never disagree: both come from the settings,-/// recomputed every frame, with no state of their own.-///-/// The running maximum is what makes the curve monotone. Two neighbouring regions pushed opposite-/// ways can otherwise fold it back on itself, and a fold is exactly what a drawn line used to show-/// while the renderer straightened it out.-pub(crate) struct ParametricCurve {- /// The curve, sampled and already forced monotone.- lut: [f32; PARAM_LUT],- /// The three region boundaries as fractions of the graph.- pub(crate) splits: [f64; 3],- /// The four region amounts, in graph order (0 = the darkest).- pub(crate) amounts: [f64; 4],-}--impl ParametricCurve {- pub(crate) fn new(c: &ToneCurve) -> ParametricCurve {- let splits = [c.split_shadows / 100.0, c.split_mid / 100.0, c.split_highlights / 100.0];- let amounts = [c.shadows, c.darks, c.lights, c.highlights];- let s = [splits[0] as f32, splits[1] as f32, splits[2] as f32];- let regions = [(0.0, s[0], amounts[0]), (s[0], s[1], amounts[1]), (s[1], s[2], amounts[2]), (s[2], 1.0, amounts[3])];- let mut lut = [0.0_f32; PARAM_LUT];- let mut prev = 0.0_f32;- for i in 0..PARAM_LUT {- let x = i as f32 / (PARAM_LUT - 1) as f32;- let mut d = 0.0_f32;- for (a, b, amt) in regions {- if amt == 0.0 {- continue;- }- let (ctr, half) = ((a + b) / 2.0, (b - a) * 0.75 + 0.05);- let t = ((x - ctr) / half).clamp(-1.0, 1.0);- d += (amt / 100.0) as f32 * 0.22 * (0.5 + 0.5 * (t * std::f32::consts::PI).cos());- }- let y = (x + d * 4.0 * x * (1.0 - x)).clamp(0.0, 1.0);- // the running maximum: the renderer's own monotone pass- prev = prev.max(y);- lut[i] = prev;- }- ParametricCurve { lut, splits, amounts }- }-- /// The curve at `x` (0 = black, 1 = white), read off the table (so it never overshoots the ends).- pub(crate) fn at(&self, x: f64) -> f64 {- let x = x.clamp(0.0, 1.0) as f32;- let at = x * (PARAM_LUT - 1) as f32;- let i = at.floor().clamp(0.0, (PARAM_LUT - 1) as f32) as usize;- let next = self.lut.get(i + 1).copied().unwrap_or(self.lut[i]);- let f = at - i as f32;- (self.lut[i] + (next - self.lut[i]) * f) as f64- }-- /// Where region `region`'s handle sits on the input axis: the middle of its own window, so a- /// handle never has to cross a split to be grabbed.- pub(crate) fn region_x(&self, region: usize) -> f64 {- let (a, b) = self.region_window(region);- (a + b) / 2.0- }-- /// The window (two splits, as fractions of the graph) region `region` owns.- fn region_window(&self, region: usize) -> (f64, f64) {- let s = [self.splits[0], self.splits[1], self.splits[2]];- match region {- 0 => (0.0, s[0]),- 1 => (s[0], s[1]),- 2 => (s[1], s[2]),- _ => (s[2], 1.0),- }- }-- /// The half-width of region `region`'s own bump, as fraction of the graph.- fn region_half(&self, region: usize) -> f64 {- let (a, b) = self.region_window(region);- (b - a) * 0.75 + 0.05- }-- /// The cosine window region `region` applies at `x` (1 at its centre, 0 at the window edges).- fn region_window_at(&self, region: usize, x: f64) -> f64 {- let ctr = self.region_x(region);- let t = ((x - ctr) / self.region_half(region)).clamp(-1.0, 1.0);- 0.5 + 0.5 * (t * std::f64::consts::PI).cos()- }-- /// The region that owns graph position `x`: the one whose own window contains it. The four- /// windows tile 0..1, so this is always defined and a drag anywhere on the curve moves exactly- /// one slider — the region under the pointer.- pub(crate) fn region_at(&self, x: f64) -> usize {- let x = x.clamp(0.0, 1.0);- // the bands are black..split0, split0..split1, split1..split2, split2..white- let (s0, s1, s2) = (self.split_x(0), self.split_x(1), self.split_x(2));- if x <= s0 {- 0- } else if x <= s1 {- 1- } else if x <= s2 {- 2- } else {- 3- }- }-- /// How much output level region `region`'s bump gains at `x` per unit of its slider: the bump is- /// linear in the amount, so this is a constant for a given `x`. A drag converts the pointer's- /// vertical motion into a slider change through it.- pub(crate) fn level_per_unit(&self, region: usize, x: f64) -> f64 {- let x = x.clamp(0.0, 1.0);- 0.22 / 100.0 * self.region_window_at(region, x) * 4.0 * x * (1.0 - x)- }-- /// The curve level region `region` sits at when its slider holds `amount`, at graph position `x`- /// — where the curve is at the point a drag grabbed, which is what that drag starts from.- pub(crate) fn handle_level_at(&self, region: usize, amount: f64, x: f64) -> f64 {- (x.clamp(0.0, 1.0) + amount * self.level_per_unit(region, x)).clamp(0.0, 1.0)- }-- /// The amount that puts region `region`'s curve at `level` at `x` — the inverse of- /// [`Self::handle_level_at`]. A level the region cannot reach saturates rather than jumping.- pub(crate) fn amount_at_level(&self, region: usize, level: f64, x: f64) -> f64 {- let per_unit = self.level_per_unit(region, x);- if per_unit.abs() <= f64::EPSILON {- return 0.0;- }- ((level.clamp(0.0, 1.0) - x.clamp(0.0, 1.0)) / per_unit).clamp(-100.0, 100.0).round()- }-- /// The graph position split `split` (0..3) sits at, 0..1.- pub(crate) fn split_x(&self, split: usize) -> f64 {- self.splits.get(split).copied().unwrap_or(0.5)- }-}-/// Close a graph drag's `develop` interaction, as one undo step.////// It is closed when the drag ends *or* the pointer comes up without egui reporting `drag_stopped`@@ -1108,9 +969,9 @@ fn param_drag(app: &mut LightcraftApp, ui: &mut egui::Ui, r: Rect, resp: &egui::};let drag_id = egui::Id::new("curve-param-drag");let cursor_id = egui::Id::new("curve-param-cursor");- // the region being dragged, and the graph x the drag is anchored at (stored as an `Option` so a- // stale value can be cleared, as the point-curve editor's drag state is)- let mut dragged: Option<(usize, f64)> = ui.data(|dd| dd.get_temp::<Option<(usize, f64)>>(drag_id)).flatten();+ // (region, x, initial_amount, start_y): the region being dragged, the graph x the drag is anchored+ // at, the region's starting amount, and the starting screen Y position.+ let mut dragged: Option<(usize, f64, f64, f32)> = ui.data(|dd| dd.get_temp::<Option<(usize, f64, f64, f32)>>(drag_id)).flatten();let hovered = dragged.is_none() && resp.hover_pos().is_some_and(|q| near_curve(q) <= PARAM_GRAB);let mut set: Option<(&'static str, f64)> = None;// the press, not where the pointer is once the drag threshold has passed: a press slightly off@@ -1122,10 +983,13 @@ fn param_drag(app: &mut LightcraftApp, ui: &mut egui::Ui, r: Rect, resp: &egui::{let x = from_screen_x(q);let _ = app.run("develop.beginInteraction", json!({"label": "Parametric Curve"}));- dragged = Some((model.region_at(x), x));- ui.data_mut(|dd| dd.insert_temp(cursor_id, to_screen(x, model.at(x))));+ let region = model.region_at(x);+ let initial_amount = model.amounts.get(region).copied().unwrap_or(0.0);+ let start_pos = to_screen(x, model.at(x));+ dragged = Some((region, x, initial_amount, start_pos.y));+ ui.data_mut(|dd| dd.insert_temp(cursor_id, start_pos));}- if let Some((region, x)) = dragged+ if let Some((region, x, initial_amount, start_y)) = dragged&& resp.dragged(){// Follow the pointer's motion from where the curve was grabbed, so the press itself moves@@ -1133,11 +997,16 @@ fn param_drag(app: &mut LightcraftApp, ui: &mut egui::Ui, r: Rect, resp: &egui::let alt = ui.input(|i| i.modifiers.alt);let dd = ui.input(|i| i.pointer.delta());let step = if alt { vec2(dd.x * 0.1, dd.y * 0.1) } else { vec2(dd.x, dd.y) };- let start = to_screen(x, model.handle_level_at(region, model.amounts[region], x));- let cursor = ui.data(|d| d.get_temp::<Pos2>(cursor_id)).unwrap_or(start) + step;+ let cursor = ui.data(|d| d.get_temp::<Pos2>(cursor_id)).unwrap_or(pos2(0.0, start_y)) + step;ui.data_mut(|d| d.insert_temp(cursor_id, cursor));- let level = ((r.bottom() - cursor.y) / r.height()).clamp(0.0, 1.0) as f64;- set = Some((PARAM_AMOUNTS[region], model.amount_at_level(region, level, x)));+ let delta_y = start_y - cursor.y;+ let delta_level = (delta_y / r.height()) as f64;+ let per_unit = model.level_per_unit(region, x);+ let new_amount =+ if per_unit.abs() > f64::EPSILON { (initial_amount + delta_level / per_unit).clamp(-100.0, 100.0).round() } else { initial_amount };+ if let Some(&id) = PARAM_AMOUNTS.get(region) {+ set = Some((id, new_amount));+ }}if let Some((id, v)) = set {let _ = app.run("develop.set", json!({"control": id, "value": v}));@@ -1147,7 +1016,7 @@ fn param_drag(app: &mut LightcraftApp, ui: &mut egui::Ui, r: Rect, resp: &egui::dragged = None;ui.data_mut(|d| {d.remove::<Pos2>(cursor_id);- d.remove::<Option<(usize, f64)>>(drag_id);+ d.remove::<Option<(usize, f64, f64, f32)>>(drag_id);});}ui.data_mut(|dd| dd.insert_temp(drag_id, dragged));@@ -1157,13 +1026,13 @@ fn param_drag(app: &mut LightcraftApp, ui: &mut egui::Ui, r: Rect, resp: &egui::ui.ctx().set_cursor_icon(egui::CursorIcon::Grab);}// the region under the pointer (or the one in hand), named as its slider below reads it- let shown = dragged.map(|(region, _)| region).or_else(|| hovered.then(|| resp.hover_pos()).flatten().map(|q| model.region_at(from_screen_x(q))));- if let Some(region) = shown {- let id = PARAM_AMOUNTS[region];- if let Some(v) = controls::get(d, id) {- let name = controls::find(id).map_or("", |s| s.label);- ui.painter().text(r.left_top() + vec2(6.0, 4.0), Align2::LEFT_TOP, format!("{name} {v:.0}"), t.font(11.0), t.text_dim);- }+ let shown = dragged.map(|(region, ..)| region).or_else(|| hovered.then(|| resp.hover_pos()).flatten().map(|q| model.region_at(from_screen_x(q))));+ if let Some(region) = shown+ && let Some(&id) = PARAM_AMOUNTS.get(region)+ && let Some(v) = controls::get(d, id)+ {+ let name = controls::find(id).map_or("", |s| s.label);+ ui.painter().text(r.left_top() + vec2(6.0, 4.0), Align2::LEFT_TOP, format!("{name} {v:.0}"), t.font(11.0), t.text_dim);}}diff --git a/crates/ui-egui/src/tests_curve.rs b/crates/ui-egui/src/tests_curve.rsindex 7dd86e512..e9bbc9c92 100644--- a/crates/ui-egui/src/tests_curve.rs+++ b/crates/ui-egui/src/tests_curve.rs@@ -5,8 +5,8 @@ use std::time::Duration;use serde_json::json;use crate::headless::Headless;-use crate::panels::edit::ParametricCurve;use crate::{LightcraftApp, Services};+use lightcraft_pipeline::ParametricCurve;const T: Duration = Duration::from_secs(20);@@ -247,7 +247,7 @@ fn the_parametric_model_is_monotone_where_the_bare_sum_of_bumps_is_not() {}x + d * 4.0 * x * (1.0 - x)};- assert!((0..=64).any(|i| raw(i as f64 / 64.0) < raw((i + 1) as f64 / 64.0)), "the shape folds back, or it proves nothing");+ assert!((0..=64).any(|i| raw(i as f64 / 64.0) > raw((i + 1) as f64 / 64.0)), "the shape folds back, or it proves nothing");let model = ParametricCurve::new(&c);let mut prev = f64::MIN;for i in 0..=256 {@@ -426,12 +426,36 @@ fn dragging_the_curve_moves_the_region_slider() {// the graph really is redrawn below where the line waslet graph = curve_graph_rect(&mut h);let painted = painted_param_curve(&h, graph)(0.625);- assert!(painted < c.lights / 100.0 + 0.625, "the painted line followed the drag down: {painted}");+ let before_level = ParametricCurve::new(&c).at(0.625);+ assert!(painted < before_level - 0.02, "the painted line followed the drag down: {painted} vs before {before_level}");// and Undo takes the whole gesture back to where it startedexec(&mut h, "edit.undo", json!({}));assert_eq!(develop(&h).curve, c, "undo restores the value the drag started from");}+/// A horizontal drag on the curve (zero vertical motion) changes no region amount, even when+/// neighbouring regions contribute heavily to the curve at the grabbed position (AlexChambers report:+/// Darks=60, Lights=0 grabbed at x=0.51 used to jump Lights to 45 with zero vertical motion).+#[test]+fn a_horizontal_drag_with_zero_vertical_motion_changes_nothing() {+ let mut h = curve_open("parametric");+ exec(&mut h, "develop.set", json!({"control": "curve.darks", "value": 60}));+ h.step();+ let before = develop(&h).curve;+ assert_eq!(before.darks, 60.0);+ assert_eq!(before.lights, 0.0);+ let r = curve_graph_rect(&mut h);+ let [x, y] = on_curve(r, &before, 0.51);+ // Drag purely horizontally from x=0.51: dx = 20 px, dy = 0+ let d = h.request("ui.drag", json!({"x": x, "y": y, "toX": x + 20.0, "toY": y, "steps": 6}), T);+ assert_eq!(d["ok"], true, "{d}");+ h.step();+ let after = develop(&h).curve;+ assert_eq!(after.lights, 0.0, "horizontal motion preserves Lights=0: {}", after.lights);+ assert_eq!(after.darks, 60.0, "Darks is preserved: {}", after.darks);+ assert_eq!(after, before, "horizontal drag changes nothing: {after:?}");+}+/// Dragging up bends the region the other way, so the gesture is not just "downwards works".#[test]fn dragging_the_curve_up_raises_the_region_slider() {@@ -529,8 +553,9 @@ fn a_curve_level_and_its_amount_are_inverses() {let model = ParametricCurve::new(&c);for region in 0..4 {let centre = model.region_x(region);+ let (_, upper) = model.region_window(region);// the region's window centre, and a point off-centre inside the same window- for x in [centre, centre + (model.split_x(region) - centre) * 0.5] {+ for x in [centre, centre + (upper - centre) * 0.5] {for amount in [-100.0, -40.0, 0.0, 30.0, 100.0] {let level = model.handle_level_at(region, amount, x);let back = model.amount_at_level(region, level, x);