add color wheel image choice

app.py

@@ -2,6 +2,8 @@ from interactive_pipe import interactive_pipeline, interactive
 from interactive_pipe.data_objects.curves import SingleCurve, Curve
 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 numpy as np
 
 
@@ -9,10 +11,18 @@ def histogram(img: np.ndarray) -> Curve:
     hist_curves = []
     for ch in range(img.shape[-1]):
         hist, bins = np.histogram(
-            img[..., ch].flatten(), bins=128, range=(0, 1))
-        hist_curves.append(SingleCurve(bins[:-1], hist, style='rgb'[ch]+"-"))
-    hist_curve = Curve(hist_curves,
-                       xlabel="Intensity", ylabel="Frequency")
+            img[..., ch].flatten(),
+            bins=128,
+            range=(0, 1)
+        )
+        hist_curves.append(
+            SingleCurve(bins[:-1], hist, style='rgb'[ch]+"-")
+        )
+    hist_curve = Curve(
+        hist_curves,
+        xlabel="Intensity",
+        ylabel="Frequency"
+    )
     return hist_curve
 
 
@@ -28,16 +38,26 @@ def set_tone_mapping_params(
     global_params["exposure"] = exposure
 
 
-def s_curve_tone_mapping(img: np.ndarray, global_params={}) -> np.ndarray:
+@interactive(apply_tone_curve_on_luma=(True,))
+def s_curve_tone_mapping(
+    img: np.ndarray,
+    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.)
-    return apply_s_curve_tone_mapping(
-        img,
+    if not apply_tone_curve_on_luma:
+        return apply_s_curve_tone_mapping(img, shadow_boost, highlight_boost, exposure)
+    hsv = rgb_to_hsv(img)
+    luma_tone_mapped = apply_s_curve_tone_mapping(
+        hsv[..., -1],
         shadow_boost,
         highlight_boost,
         exposure
     )
+    hsv[..., -1] = luma_tone_mapped
+    return hsv_to_rgb(hsv)
 
 
 def s_curve_visualization(global_params={}) -> Curve:
@@ -57,8 +77,29 @@ def s_curve_visualization(global_params={}) -> Curve:
     )
 
 
-@ interactive_pipeline(gui="gradio")
-def image_editing_pipeline(input_image):
+@interactive(
+    input_image=("sample_image", ["sample_image", "color_wheel"]),
+)
+def pick_image(
+    default_image: np.ndarray,
+    input_image: str = "sample_image",
+    global_params={}
+) -> np.ndarray:
+    if input_image == "sample_image":
+        return default_image
+    elif input_image == "color_wheel":
+        color_wheel = global_params.get("color_wheel", None)
+        if color_wheel is None:
+            color_wheel = generate_color_wheel(resolution=496)
+            global_params["color_wheel"] = color_wheel
+        return color_wheel
+    else:
+        return default_image
+
+
+@interactive_pipeline(gui="gradio")
+def image_editing_pipeline(sample_image):
+    input_image = pick_image(sample_image)
     set_tone_mapping_params()
     tc_image = s_curve_tone_mapping(input_image)
     tone_curve = s_curve_visualization()
@@ -67,5 +108,5 @@ def image_editing_pipeline(input_image):
 
 
 if __name__ == "__main__":
-    img = Image.load_image("image_sample.png")
+    img = Image.load_image("image_sample.jpg")
     image_editing_pipeline(img)

color_conversions.py

@@ -0,0 +1,100 @@
+import numpy as np
+
+
+def rgb_to_hsv(rgb):
+    # Ensure the input is a float numpy array and in the range [0, 1]
+    rgb = np.asarray(rgb)
+
+    # Separate the R, G, B channels
+    r, g, b = rgb[..., 0], rgb[..., 1], rgb[..., 2]
+
+    # Max and min of RGB values
+    max_rgb = np.max(rgb, axis=-1)
+    min_rgb = np.min(rgb, axis=-1)
+    delta = max_rgb - min_rgb
+
+    # Hue calculation
+    hue = np.zeros_like(max_rgb)
+    mask = delta != 0
+
+    # Red is max
+    idx = (max_rgb == r) & mask
+    hue[idx] = (60 * ((g - b) / delta % 6))[idx]
+
+    # Green is max
+    idx = (max_rgb == g) & mask
+    hue[idx] = (60 * ((b - r) / delta + 2))[idx]
+
+    # Blue is max
+    idx = (max_rgb == b) & mask
+    hue[idx] = (60 * ((r - g) / delta + 4))[idx]
+
+    # Saturation calculation
+    saturation = np.zeros_like(max_rgb)
+    saturation[mask] = delta[mask] / max_rgb[mask]
+
+    # Value calculation
+    value = max_rgb
+
+    # Stack the HSV components together
+    hsv = np.stack((hue, saturation, value), axis=-1)
+
+    return hsv
+
+
+def hsv_to_rgb(hsv):
+    # Ensure the input is a float numpy array and in the range [0, 1]
+    hsv = np.asarray(hsv)
+
+    # Separate the H, S, V channels
+    h, s, v = hsv[..., 0], hsv[..., 1], hsv[..., 2]
+
+    # Chromaticity component
+    c = v * s
+    x = c * (1 - np.abs((h / 60) % 2 - 1))
+    m = v - c
+
+    # Initialize RGB
+    r, g, b = np.zeros_like(h), np.zeros_like(h), np.zeros_like(h)
+
+    # Compute the RGB components based on the hue range
+    h0_60 = (h >= 0) & (h < 60)
+    r[h0_60], g[h0_60], b[h0_60] = c[h0_60], x[h0_60], 0
+
+    h60_120 = (h >= 60) & (h < 120)
+    r[h60_120], g[h60_120], b[h60_120] = x[h60_120], c[h60_120], 0
+
+    h120_180 = (h >= 120) & (h < 180)
+    r[h120_180], g[h120_180], b[h120_180] = 0, c[h120_180], x[h120_180]
+
+    h180_240 = (h >= 180) & (h < 240)
+    r[h180_240], g[h180_240], b[h180_240] = 0, x[h180_240], c[h180_240]
+
+    h240_300 = (h >= 240) & (h < 300)
+    r[h240_300], g[h240_300], b[h240_300] = x[h240_300], 0, c[h240_300]
+
+    h300_360 = (h >= 300) & (h < 360)
+    r[h300_360], g[h300_360], b[h300_360] = c[h300_360], 0, x[h300_360]
+
+    # Add m to each component and stack them together
+    rgb = np.stack((r + m, g + m, b + m), axis=-1)
+
+    return rgb
+
+
+def test_conversion():
+    # RGB array example (range [0, 1])
+    rgb = np.array([[[0.5, 0.4, 0.7], [0.1, 0.2, 0.3]],
+                    [[0.8, 0.7, 0.6], [0.9, 0.1, 0.2]]])
+    # rgb = np.random.rand(1000, 100, 3)
+    # Convert RGB to HSV
+    hsv = rgb_to_hsv(rgb)
+    print(hsv.shape)
+
+    # Convert HSV back to RGB
+    rgb_back = hsv_to_rgb(hsv)
+    assert np.allclose(rgb, rgb_back), "Conversion failed!"
+
+
+if __name__ == "__main__":
+    test_conversion()

synthetic_charts.py

@@ -0,0 +1,40 @@
+
+import numpy as np
+from color_conversions import hsv_to_rgb
+
+
+def generate_color_wheel(resolution=500) -> np.ndarray:
+    """
+    Generate a color wheel image using HSV to RGB conversion.
+
+    :param resolution: The width/height of the square image
+    :return: RGB image of the color wheel
+    """
+    # Create a 2D grid of indices (X, Y) to calculate the angle and radius
+    x = np.linspace(-1, 1, resolution)
+    y = np.linspace(-1, 1, resolution)
+    xv, yv = np.meshgrid(x, y)
+
+    # Calculate angle (hue) in degrees
+    angle = np.arctan2(yv, xv) * (180 / np.pi) + 180  # Range from 0 to 360
+
+    # Calculate radius from the center (used for saturation)
+    radius = np.sqrt(xv**2 + yv**2)
+
+    # Normalize radius to range [0, 1]
+    radius = np.clip(radius, 0, 1)
+
+    # HSV components
+    hue = angle  # Hue is the angle
+    saturation = radius  
+    # Saturation is proportional to the distance from the center
+    # Value is constant (1) for maximum brightness
+    value = np.ones_like(radius)
+
+    # Stack the HSV components into a single array
+    hsv_image = np.stack((hue, saturation, value), axis=-1)
+
+    # Convert the HSV image to RGB
+    rgb_image = hsv_to_rgb(hsv_image)
+
+    return rgb_image