update tone mapping curve (3 points Hermite Cubic Spline)

app.py

@@ -4,6 +4,7 @@ from interactive_pipe.data_objects.image import Image
 from global_tone_mapping import apply_s_curve_tone_mapping
 from color_conversions import rgb_to_hsv, hsv_to_rgb
 from synthetic_charts import generate_color_wheel
+import argparse
 import numpy as np
 
 
@@ -31,10 +32,12 @@ def set_tone_mapping_params(
     shadow_boost: float = (0., [-1., 1.]),
     highlight_boost: float = (0., [-1., 1.]),
     exposure: float = (0., [-1., 1.]),
+    contrast: float = (0., [-1., 1.]),
     global_params: dict = {}
 ) -> None:
     global_params["shadow_boost"] = shadow_boost
     global_params["highlight_boost"] = highlight_boost
+    global_params["contrast"] = contrast
     global_params["exposure"] = exposure
 
 
@@ -44,16 +47,24 @@ def s_curve_tone_mapping(
     apply_tone_curve_on_luma: bool = True,
     global_params={}
 ) -> np.ndarray:
-    exposure = global_params.get("exposure", 0.)
     shadow_boost = global_params.get("shadow_boost", 0.)
     highlight_boost = global_params.get("highlight_boost", 0.)
+    contrast = global_params.get("contrast", 0.)
+    exposure = global_params.get("exposure", 0.)
     if not apply_tone_curve_on_luma:
-        return apply_s_curve_tone_mapping(img, shadow_boost, highlight_boost, exposure)
+        return apply_s_curve_tone_mapping(
+            img,
+            shadow_boost,
+            highlight_boost,
+            contrast,
+            exposure
+        )
     hsv = rgb_to_hsv(img)
     luma_tone_mapped = apply_s_curve_tone_mapping(
         hsv[..., -1],
         shadow_boost,
         highlight_boost,
+        contrast,
         exposure
     )
     hsv[..., -1] = luma_tone_mapped
@@ -61,12 +72,14 @@ def s_curve_tone_mapping(
 
 
 def s_curve_visualization(global_params={}) -> Curve:
-    exposure = global_params.get("exposure", 0.)
     shadow_boost = global_params.get("shadow_boost", 0.)
     highlight_boost = global_params.get("highlight_boost", 0.)
+    contrast = global_params.get("contrast", 0.)
+    exposure = global_params.get("exposure", 0.)
     x = np.linspace(0, 1, 256)
     y = apply_s_curve_tone_mapping(x, shadow_boost,
                                    highlight_boost,
+                                   contrast,
                                    exposure)
     return Curve(
         [
@@ -97,7 +110,6 @@ def pick_image(
         return default_image
 
 
-@interactive_pipeline(gui="gradio")
 def image_editing_pipeline(sample_image):
     input_image = pick_image(sample_image)
     set_tone_mapping_params()
@@ -108,5 +120,9 @@ def image_editing_pipeline(sample_image):
 
 
 if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-b", "--backend", type=str,
+                        choices=["gradio", "qt", "mpl"], default="gradio")
+    args = parser.parse_args()
     img = Image.load_image("image_sample.jpg")
-    image_editing_pipeline(img)
+    interactive_pipeline(gui=args.backend)(image_editing_pipeline)(img)

global_tone_mapping.py

@@ -5,7 +5,8 @@ def apply_s_curve_tone_mapping(
     x: np.ndarray,
     shadow_boost: float = 0.,
     highlight_boost: float = 0.,
-    exposure: float = 0.,
+    contrast: float = 0.,
+    exposure: float = 0.
 ) -> np.ndarray:
     """
     Apply an S-curve tone mapping to input x with given parameters.
@@ -14,31 +15,69 @@ def apply_s_curve_tone_mapping(
     x : array-like
         Input values in the range [0, 1].
     shadow_boost : float
-        Shadow boost parameter (tangent).
-        Positive values decreases the steepness in shadows.
+        Shadow boost parameter. Positive values increase the steepness in shadows.
     highlight_boost : float
-        Highlight boost parameter (tangent). 
-        Positive values increase the steepness in highlights.
+        Highlight boost parameter. Positive values increase the steepness in highlights.
+    contrast : float
+        Contrast parameter. Positive values increase the steepness at midtones.
     exposure : float
         Exposure adjustment parameter. When exposure=0, 0.5 maps to 0.5.
+        Exposure defines the mapping of 0.5 to 0.5 * (2 ** exposure).
 
     Returns:
     y : array-like
         Tone-mapped output values in the range [0, 1].
     """
-    x_expo = np.clip(x * 2 ** exposure, 0, 1)
 
-    # Adjust s and h parameters
-    s = 1 - shadow_boost
-    h = 1 + highlight_boost
+    # Compute the midtone mapped value based on exposure
+    midtone_mapped_value = 0.5 * (2 ** exposure)
+    midtone_mapped_value = np.clip(midtone_mapped_value, 0, 1)
 
-    # Compute numerator and denominator for the S-curve formula
-    numerator = x_expo ** s
-    denominator = numerator + (1 - x_expo) ** h
+    # Define the slopes (derivatives) at the three key points
+    s0 = 1 + shadow_boost       # Slope at x = 0 (shadows)
+    s1 = 1 + contrast           # Slope at x = 0.5 (midtone)
+    s2 = 1 + highlight_boost    # Slope at x = 1 (highlights)
 
-    # Avoid division by zero
-    with np.errstate(divide='ignore', invalid='ignore'):
-        y = numerator / denominator
-        y = np.nan_to_num(y)
+    # Initialize the output array
+    y = np.zeros_like(x)
+
+    # Segment 1: x in [0, 0.5]
+    idx1 = x <= 0.5
+    x0, x1 = 0.0, 0.5
+    y0, y1 = 0.0, midtone_mapped_value
+    m0, m1 = s0, s1
+    delta_x = x1 - x0
+
+    t = (x[idx1] - x0) / delta_x  # Normalize x to parameter t in [0, 1]
+
+    # Hermite basis functions
+    h00 = 2 * t ** 3 - 3 * t ** 2 + 1
+    h10 = t ** 3 - 2 * t ** 2 + t
+    h01 = -2 * t ** 3 + 3 * t ** 2
+    h11 = t ** 3 - t ** 2
+
+    # Calculate the spline for the first segment
+    y[idx1] = (h00 * y0 + h10 * m0 * delta_x + h01 * y1 + h11 * m1 * delta_x)
+
+    # Segment 2: x in (0.5, 1]
+    idx2 = x > 0.5
+    x0, x1 = 0.5, 1.0
+    y0, y1 = midtone_mapped_value, 1.0
+    m0, m1 = s1, s2
+    delta_x = x1 - x0
+
+    t = (x[idx2] - x0) / delta_x  # Normalize x to parameter t in [0, 1]
+
+    # Hermite basis functions for the second segment
+    h00 = 2 * t ** 3 - 3 * t ** 2 + 1
+    h10 = t ** 3 - 2 * t ** 2 + t
+    h01 = -2 * t ** 3 + 3 * t ** 2
+    h11 = t ** 3 - t ** 2
+
+    # Calculate the spline for the second segment
+    y[idx2] = (h00 * y0 + h10 * m0 * delta_x + h01 * y1 + h11 * m1 * delta_x)
+
+    # Ensure the output is within [0, 1]
+    y = np.clip(y, 0, 1)
 
     return y