feat: Sharpening Mask

src-tauri/src/file_management.rs

@@ -2263,7 +2263,7 @@ pub fn move_files(source_paths: Vec<String>, destination_folder: String) -> Resu
 #[tauri::command]
 pub fn save_metadata_and_update_thumbnail(
     path: String,
-    adjustments: Value,
+    mut adjustments: Value,
     app_handle: AppHandle,
     state: tauri::State<AppState>,
 ) -> Result<(), String> {
@@ -2278,6 +2278,10 @@ pub fn save_metadata_and_update_thumbnail(
         ImageMetadata::default()
     };
 
+    if let Some(obj) = adjustments.as_object_mut() {
+        obj.remove("sharpeningMaskShowBw");
+    }
+
     metadata.adjustments = adjustments;
 
     let json_string = serde_json::to_string_pretty(&metadata).map_err(|e| e.to_string())?;

src-tauri/src/image_processing.rs

@@ -1263,6 +1263,7 @@ pub struct GlobalAdjustments {
     pub vibrance: f32,
 
     pub sharpness: f32,
+    pub sharpening_mask: f32,
     pub luma_noise_reduction: f32,
     pub color_noise_reduction: f32,
     pub clarity: f32,
@@ -1293,7 +1294,6 @@ pub struct GlobalAdjustments {
 
     _pad_agx1: f32,
     _pad_agx2: f32,
-    _pad_agx3: f32,
     pub agx_pipe_to_rendering_matrix: GpuMat3,
     pub agx_rendering_to_pipe_matrix: GpuMat3,
 
@@ -1324,13 +1324,13 @@ pub struct GlobalAdjustments {
     _pad_end1: f32,
     _pad_end2: f32,
     _pad_end3: f32,
-    _pad_end4: f32,
+    pub sharpening_mask_show_bw: u32,
 
     pub glow_amount: f32,
     pub halation_amount: f32,
     pub flare_amount: f32,
 
-    _pad_creative_1: f32,
+    pub sharpening_mask_debug: u32,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, Copy, Pod, Zeroable, Default)]
@@ -1730,9 +1730,9 @@ pub fn apply_cpu_agx_tonemap(image: &mut DynamicImage) {
 
     const LUT_SIZE: usize = 4096;
     let mut curve_lut = [0.0f32; LUT_SIZE];
-    for i in 0..LUT_SIZE {
+    for (i, slot) in curve_lut.iter_mut().enumerate() {
         let x = i as f32 / (LUT_SIZE - 1) as f32;
-        curve_lut[i] = agx_curve_channel(x).max(0.0).powf(AGX_GAMMA);
+        *slot = agx_curve_channel(x).max(0.0).powf(AGX_GAMMA);
     }
 
     let (pipe_to_rendering, rendering_to_pipe) = calculate_agx_matrices_glam();
@@ -1889,6 +1889,7 @@ fn get_global_adjustments_from_json(
         vibrance: get_val("color", "vibrance", SCALES.vibrance, None),
 
         sharpness: get_val("details", "sharpness", SCALES.sharpness, None),
+        sharpening_mask: get_val("details", "sharpeningMask", 1.0, None),
         luma_noise_reduction: get_val(
             "details",
             "lumaNoiseReduction",
@@ -1969,7 +1970,6 @@ fn get_global_adjustments_from_json(
 
         _pad_agx1: 0.0,
         _pad_agx2: 0.0,
-        _pad_agx3: 0.0,
         agx_pipe_to_rendering_matrix: pipe_to_rendering,
         agx_rendering_to_pipe_matrix: rendering_to_pipe,
 
@@ -2028,13 +2028,27 @@ fn get_global_adjustments_from_json(
         _pad_end1: 0.0,
         _pad_end2: 0.0,
         _pad_end3: 0.0,
-        _pad_end4: 0.0,
+        sharpening_mask_show_bw: if js_adjustments["sharpeningMaskShowBw"]
+            .as_bool()
+            .unwrap_or(false)
+        {
+            1
+        } else {
+            0
+        },
 
         glow_amount: get_val("effects", "glowAmount", SCALES.glow, None),
         halation_amount: get_val("effects", "halationAmount", SCALES.halation, None),
         flare_amount: get_val("effects", "flareAmount", SCALES.flares, None),
 
-        _pad_creative_1: 0.0,
+        sharpening_mask_debug: if js_adjustments["sharpeningMaskDebug"]
+            .as_bool()
+            .unwrap_or(false)
+        {
+            1
+        } else {
+            0
+        },
     }
 }
 

src-tauri/src/lib.rs

@@ -1955,6 +1955,7 @@ fn apply_export_resize_and_watermark(
     Ok(image)
 }
 
+#[allow(clippy::too_many_arguments)]
 fn process_image_for_export_pipeline(
     path: &str,
     base_image: &DynamicImage,
@@ -1992,6 +1993,8 @@ fn process_image_for_export_pipeline(
     let tm_override = resolve_tonemapper_override_from_handle(app_handle, is_raw);
     let mut all_adjustments = get_all_adjustments_from_json(js_adjustments, is_raw, tm_override);
     all_adjustments.global.show_clipping = 0;
+    all_adjustments.global.sharpening_mask_debug = 0;
+    all_adjustments.global.sharpening_mask_show_bw = 0;
 
     let lut_path = js_adjustments["lutPath"].as_str();
     let lut = lut_path.and_then(|p| get_or_load_lut(state, p).ok());
@@ -2079,6 +2082,7 @@ fn mime_type_for_extension(extension: &str) -> &'static str {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn process_image_for_export(
     path: &str,
     base_image: &DynamicImage,

src-tauri/src/shaders/shader.wgsl

@@ -44,6 +44,7 @@ struct GlobalAdjustments {
     vibrance: f32,
 
     sharpness: f32,
+    sharpening_mask: f32,
     luma_noise_reduction: f32,
     color_noise_reduction: f32,
     clarity: f32,
@@ -74,7 +75,6 @@ struct GlobalAdjustments {
 
     _pad_agx1: f32,
     _pad_agx2: f32,
-    _pad_agx3: f32,
     agx_pipe_to_rendering_matrix: mat3x3<f32>,
     agx_rendering_to_pipe_matrix: mat3x3<f32>,
 
@@ -105,13 +105,13 @@ struct GlobalAdjustments {
     _pad_end1: f32,
     _pad_end2: f32,
     _pad_end3: f32,
-    _pad_end4: f32,
+    sharpening_mask_show_bw: u32,
 
     glow_amount: f32,
     halation_amount: f32,
     flare_amount: f32,
 
-    _pad_creative_1: f32,
+    sharpening_mask_debug: u32,
 }
 
 struct MaskAdjustments {
@@ -1387,7 +1387,41 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let structure_blurred = textureLoad(structure_blur_texture, id.xy, 0).rgb;
 
     var locally_contrasted_rgb = initial_linear_rgb;
-    locally_contrasted_rgb = apply_local_contrast(locally_contrasted_rgb, sharpness_blurred, adjustments.global.sharpness, adjustments.global.is_raw_image, 0u);
+
+    var sharpen_edge_factor: f32 = 1.0;
+    if (adjustments.global.sharpening_mask > 0.0) {
+        let dims = vec2<i32>(textureDimensions(input_texture));
+        let sample_radius = max(1, i32(round(scale)));
+        let right_coord = vec2<i32>(
+            min(absolute_coord_i.x + sample_radius, dims.x - 1),
+            absolute_coord_i.y,
+        );
+        let left_coord = vec2<i32>(
+            max(absolute_coord_i.x - sample_radius, 0),
+            absolute_coord_i.y,
+        );
+        let down_coord = vec2<i32>(
+            absolute_coord_i.x,
+            min(absolute_coord_i.y + sample_radius, dims.y - 1),
+        );
+        let up_coord = vec2<i32>(
+            absolute_coord_i.x,
+            max(absolute_coord_i.y - sample_radius, 0),
+        );
+        let right_luma = get_luma(textureLoad(input_texture, right_coord, 0).rgb);
+        let left_luma = get_luma(textureLoad(input_texture, left_coord, 0).rgb);
+        let down_luma = get_luma(textureLoad(input_texture, down_coord, 0).rgb);
+        let up_luma = get_luma(textureLoad(input_texture, up_coord, 0).rgb);
+        let grad_x = (right_luma - left_luma) * 0.5;
+        let grad_y = (down_luma - up_luma) * 0.5;
+        let edge = sqrt(grad_x * grad_x + grad_y * grad_y);
+        let threshold_hi = adjustments.global.sharpening_mask * 0.25;
+        let threshold_lo = threshold_hi * 0.3;
+        sharpen_edge_factor = smoothstep(threshold_lo, threshold_hi, edge);
+    }
+    var masked_sharpness = adjustments.global.sharpness * sharpen_edge_factor;
+
+    locally_contrasted_rgb = apply_local_contrast(locally_contrasted_rgb, sharpness_blurred, masked_sharpness, adjustments.global.is_raw_image, 0u);
     locally_contrasted_rgb = apply_local_contrast(locally_contrasted_rgb, clarity_blurred, adjustments.global.clarity, adjustments.global.is_raw_image, 1u);
     locally_contrasted_rgb = apply_local_contrast(locally_contrasted_rgb, structure_blurred, adjustments.global.structure, adjustments.global.is_raw_image, 1u);
     locally_contrasted_rgb = apply_centre_local_contrast(locally_contrasted_rgb, adjustments.global.centre, absolute_coord_i, clarity_blurred, adjustments.global.is_raw_image);
@@ -1592,6 +1626,15 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
         }
     }
 
+    if (adjustments.global.sharpening_mask_debug == 1u) {
+        let SHARPEN_MASK_OVERLAY_COLOR = vec3<f32>(1.0, 0.0, 0.0);
+        final_rgb = mix(final_rgb, SHARPEN_MASK_OVERLAY_COLOR, clamp(sharpen_edge_factor, 0.0, 1.0) * 0.7);
+    }
+
+    if (adjustments.global.sharpening_mask_show_bw == 1u) {
+        final_rgb = vec3<f32>(clamp(sharpen_edge_factor, 0.0, 1.0));
+    }
+
     let dither_amount = 1.0 / 255.0;
     final_rgb += dither(id.xy) * dither_amount;