SPLINE TIME

Author: capnfabs

Cargo.lock

@@ -14,3 +14,4 @@ palette = "0.5.0"
 rayon = "1.3.0"
 num-traits = "0.2.11"
 ordered-float = "1.0.2"
+splines = "3.4.1"

blitz/Cargo.toml

@@ -45,14 +45,8 @@ pub fn render_raw_with_settings(img: &ParsedRafFile, settings: &RenderSettings)
         blue: pixel.blue * scale_factors[2],
     };
 
-    let apply_curve_floats = |pixel: f32| {
-        let coefs = settings.tone_curve.len();
-        let mut chosen = (pixel * coefs as f32) as usize;
-        if chosen >= coefs {
-            chosen = coefs - 1;
-        }
-        settings.tone_curve[chosen] * pixel
-    };
+    let apply_curve_floats =
+        |pixel: f32| settings.tone_curve.spline.clamped_sample(pixel).unwrap() * pixel;
 
     let clamp = |pixel: &Pixel<_>| Pixel {
         red: float_clamp(pixel.red),

blitz/src/render.rs

@@ -1,51 +1,63 @@
 use itertools::Itertools;
-use std::iter::once;
+use splines;
+use splines::{Interpolation, Key, Spline};
+use std::iter::{once, repeat};
 
+#[derive(Debug, Clone)]
 pub struct ToneCurve {
-    x_vals: Vec<f32>,
-    tangents: Vec<f32>,
+    pub spline: Spline<f32, f32>,
 }
 
 impl ToneCurve {
-    pub fn new(points: &Vec<f32>) -> Self {
+    pub fn new(points: &[f32]) -> Self {
         // SPLINE TIME
         // https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Catmull%E2%80%93Rom_spline
+        // TODO: figure out what's going on with the edges, they're unhappy here.
+        // Start and end at 1 because this is multiplicative.
         let x_inc = 1.0 / points.len() as f32;
+        let start = Key::new(0., 1., Interpolation::Cosine);
+        let end = Key::new(1., 1., Interpolation::default());
+
         // for 4 points, this should be 12.5, 37.5, 62.5, 87.5, i.e. split into 4 even bands
-        let x_vals = (0..points.len()).map(|x| (x as f32 + 0.5) * x_inc);
-        let xs = once(0.0).chain(x_vals).chain(once(1.0)).collect_vec();
-        let ys = once(0.0)
-            .chain(points.iter().copied())
-            .chain(once(1.0))
-            .collect_vec();
-        assert_eq!(xs.len(), ys.len());
-
-        let tangents = (1..(xs.len() - 1))
-            .map(|k| {
-                // as per wikipedia:
-                // m_k =
-                (ys[k + 1] - ys[k - 1]) / (xs[k + 1] - xs[k - 1])
-            })
-            .collect_vec();
-        ToneCurve {
-            x_vals: xs,
-            tangents,
-        }
+        let xs = (0..points.len()).map(|x| (x as f32 + 0.5) * x_inc);
+
+        let iter = once(start)
+            .chain(
+                xs.zip_eq(points.iter().copied())
+                    .map(|(x, y)| Key::new(x, y, Interpolation::CatmullRom)),
+            )
+            .chain(repeat(end).take(2));
+        let spline = Spline::from_iter(iter);
+
+        ToneCurve { spline }
     }
 
-    pub fn apply(val: f32) -> f32 {}
+    pub fn apply(&self, val: f32) -> f32 {
+        self.spline.sample(val).unwrap_or(f32::NAN)
+    }
+}
+
+impl Default for ToneCurve {
+    fn default() -> Self {
+        let spl = Spline::from_vec(vec![
+            // Flat curve
+            Key::new(0.0, 1.0, Interpolation::Linear),
+            Key::new(1.0, 1.0, Interpolation::Linear),
+        ]);
+        ToneCurve { spline: spl }
+    }
 }
 
 #[derive(Debug, Clone)]
 pub struct RenderSettings {
-    pub tone_curve: Vec<f32>,
+    pub tone_curve: ToneCurve,
     pub exposure_basis: f32,
 }
 
 impl Default for RenderSettings {
     fn default() -> Self {
         RenderSettings {
-            tone_curve: vec![1.5],
+            tone_curve: ToneCurve::default(),
             exposure_basis: 1.0,
         }
     }

blitz/src/render_settings.rs

@@ -1,5 +1,6 @@
 use blitz::render::{render_raw, render_raw_with_settings};
 use blitz::render_settings;
+use blitz::render_settings::ToneCurve;
 use libc::c_char;
 use libraw::raf::{ParsedRafFile, RafFile};
 use std::ffi::CStr;
@@ -78,13 +79,20 @@ const TONE_CURVE_CONST: f32 = 2.0;
 
 impl RenderSettings {
     fn to_blitz_settings(&self) -> render_settings::RenderSettings {
+        let coefs: Vec<_> = self
+            .tone_curve
+            .iter()
+            .copied()
+            .map(|x| TONE_CURVE_CONST.powf(x))
+            .collect();
+        let tc = ToneCurve::new(&coefs);
+        println!("Tonecurve: {:?}", tc);
+        for i in 0..100 {
+            println!("{},{}", i, tc.apply(i as f32 / 100.));
+        }
+
         render_settings::RenderSettings {
-            tone_curve: self
-                .tone_curve
-                .iter()
-                .copied()
-                .map(|x| TONE_CURVE_CONST.powf(x))
-                .collect(),
+            tone_curve: tc,
             exposure_basis: TONE_CURVE_CONST.powf(self.exposure_basis),
         }
     }

blitzexport/src/lib.rs

@@ -132,7 +132,7 @@ struct RenderControlsView: View {
             }
             HStack {
                 Text("Baseline Exposure: \(self.exposure)")
-                SlideyBoi(value: $exposure, min:-1, max:1)
+                SlideyBoi(value: $exposure, min:-5, max:5)
             }
             HStack {
                 Text("Tone Curve")