Merge pull request #20891 from jenshannoschwalm/fix_interpolators_lens

Fix interpolators lens

Author: TurboGit

data/kernels/basic.cl

@@ -1,6 +1,6 @@
 /*
     This file is part of darktable,
-    Copyright (C) 2015-2025 darktable developers.
+    Copyright (C) 2015-2026 darktable developers.
 
     darktable is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -29,7 +29,7 @@ passthrough_monochrome (__read_only image2d_t in, __write_only image2d_t out, co
 
   if(x >= width || y >= height) return;
 
-  const float pc = fmax(0.0f, read_imagef(in, sampleri, (int2)(x, y)).x);
+  const float pc = readsingle(in, x, y);
   write_imagef(out, (int2)(x, y), (float4)pc);
 }
 
@@ -46,7 +46,7 @@ passthrough_color(__read_only image2d_t in,
 
   if(x >= width || y >= height) return;
 
-  const float ival = fmax(0.0f, read_imagef(in, sampleri, (int2)(x, y)).x);
+  const float ival = readsingle(in, x, y);
   const int c = fcol(y, x, filters, xtrans);
 
   float4 oval = (float4)(0.0f, 0.0f, 0.0f, 0.0f);
@@ -96,7 +96,7 @@ clip_and_zoom_demosaic_passthrough_monochrome(__read_only image2d_t in,
     const float xfilter = (i == 0) ? 1.0f - d.x : ((i == samples+1) ? d.x : 1.0f);
     const float yfilter = (j == 0) ? 1.0f - d.y : ((j == samples+1) ? d.y : 1.0f);
 
-    const float px = fmax(0.0f, read_imagef(in, sampleri, (int2)(xx, yy)).x);
+    const float px = readsingle(in, xx, yy);
     color += yfilter*xfilter*(float4)(px, px, px, 0.0f);
     weight += yfilter*xfilter;
   }

data/kernels/demosaic_other.cl

@@ -461,37 +461,6 @@ color_smoothing(read_only image2d_t in,
 #undef cas
 
 
-
-/**
- * downscale and clip a buffer (in) to the given roi (r_*) and write it to out.
- * output will be linear in memory.
- * operates on float4 -> float4 textures.
- */
-kernel void
-clip_and_zoom(read_only image2d_t in, write_only image2d_t out, const int width, const int height,
-              const int r_x, const int r_y, const int r_wd, const int r_ht, const float r_scale)
-{
-  // global id is pixel in output image (float4)
-  const int x = get_global_id(0);
-  const int y = get_global_id(1);
-
-  if(x >= width || y >= height) return;
-
-  float4 color = (float4)(0.0f, 0.0f, 0.0f, 0.0f);
-
-  const float px_footprint = 0.5f/r_scale;
-  const int samples = ((int)px_footprint);
-  const float2 p = backtransformf((float2)(x+0.5f, y+0.5f), r_x, r_y, r_wd, r_ht, r_scale);
-  for(int j=-samples;j<=samples;j++) for(int i=-samples;i<=samples;i++)
-  {
-    const float4 px = read_imagef(in, samplerf, (float2)(p.x+i, p.y+j));
-    color += px;
-  }
-  color /= (float4)((2*samples+1)*(2*samples+1));
-  write_imagef (out, (int2)(x, y), fmax(color, 0.0f));
-}
-
-
 /**
  * downscales and clips a mosaiced buffer (in) to the given region of interest (r_*)
  * and writes it to out in float4 format.
@@ -552,10 +521,10 @@ clip_and_zoom_demosaic_half_size(__read_only image2d_t in,
     const float yfilter = (j == 0) ? 1.0f - d.y : ((j == samples+1) ? d.y : 1.0f);
 
     // get four mosaic pattern uint16:
-    const float p1 = read_imagef(in, sampleri, (int2)(xx,   yy  )).x;
-    const float p2 = read_imagef(in, sampleri, (int2)(xx+1, yy  )).x;
-    const float p3 = read_imagef(in, sampleri, (int2)(xx,   yy+1)).x;
-    const float p4 = read_imagef(in, sampleri, (int2)(xx+1, yy+1)).x;
+    const float p1 = readsingle(in, xx,   yy  );
+    const float p2 = readsingle(in, xx+1, yy  );
+    const float p3 = readsingle(in, xx,   yy+1);
+    const float p4 = readsingle(in, xx+1, yy+1);
     color += yfilter*xfilter*(float4)(p1, (p2+p3)*0.5f, p4, 0.0f);
     weight += yfilter*xfilter;
   }

data/kernels/demosaic_ppg.cl

@@ -324,7 +324,7 @@ denoiseprofile_finish(read_only image2d_t in, global float4* U2, write_only imag
   if(x >= width || y >= height) return;
 
   float4 u2   = U2[gidx];
-  const float alpha = read_imagef(in, sampleri, (int2)(x, y)).w;
+  const float alpha = readalpha(in, x, y);
 
   float4 px = ((float4)u2.w > (float4)0.0f ? u2/u2.w : (float4)0.0f);
 
@@ -349,7 +349,7 @@ denoiseprofile_finish_v2(read_only image2d_t in, global float4* U2, write_only i
   if(x >= width || y >= height) return;
 
   float4 u2   = U2[gidx];
-  const float alpha = read_imagef(in, sampleri, (int2)(x, y)).w;
+  const float alpha = readalpha(in, x, y);
 
   float4 px = ((float4)u2.w > (float4)0.0f ? u2/u2.w : (float4)0.0f);
 

data/kernels/denoiseprofile.cl

@@ -1,6 +1,6 @@
 /*
     This file is part of darktable,
-    copyright (c) 2017 edgardo hoszowski.
+    Copyright (C) 2017-2026 darktable developers.
 
     darktable is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -38,22 +38,28 @@ retouch_clear_alpha(global float4 *in, int width, int height)
 }
 
 kernel void
-retouch_copy_alpha(__read_only image2d_t in, global float4 *out, int width, int height)
+retouch_copy_alpha(__read_only image2d_t in,
+                   global float4 *out,
+                   int width,
+                   int height)
 {
   const int x = get_global_id(0);
   const int y = get_global_id(1);
 
   if(x >= width || y >= height) return;
 
-  float4 pixel = read_imagef(in, sampleri, (int2)(x, y));
+  float alpha = readalpha(in, x, y);
   const int idx = mad24(y, width, x);
-  out[idx].w = pixel.w;
+  out[idx].w = alpha;
 }
 
 kernel void
-retouch_copy_buffer_to_image(global float4 *in, global dt_iop_roi_t *roi_in,
-                                         __write_only image2d_t out, global dt_iop_roi_t *roi_out, const int xoffs,
-                                         const int yoffs)
+retouch_copy_buffer_to_image(global float4 *in,
+                             global dt_iop_roi_t *roi_in,
+                             __write_only image2d_t out,
+                             global dt_iop_roi_t *roi_out,
+                             const int xoffs,
+                             const int yoffs)
 {
   const int x = get_global_id(0);
   const int y = get_global_id(1);
@@ -66,8 +72,12 @@ retouch_copy_buffer_to_image(global float4 *in, global dt_iop_roi_t *roi_in,
 }
 
 kernel void
-retouch_copy_buffer_to_buffer(global float4 *in, global dt_iop_roi_t *roi_in, global float4 *out,
-                                          global dt_iop_roi_t *roi_out, const int xoffs, const int yoffs)
+retouch_copy_buffer_to_buffer(global float4 *in,
+                              global dt_iop_roi_t *roi_in,
+                              global float4 *out,
+                              global dt_iop_roi_t *roi_out,
+                              const int xoffs,
+                              const int yoffs)
 {
   const int x = get_global_id(0);
   const int y = get_global_id(1);
@@ -79,39 +89,45 @@ retouch_copy_buffer_to_buffer(global float4 *in, global dt_iop_roi_t *roi_in, gl
 }
 
 kernel void
-retouch_copy_mask_to_alpha(global float4 *in, global dt_iop_roi_t *roi_in, global float *mask_scaled,
-                                       global dt_iop_roi_t *roi_mask_scaled, const float opacity)
+retouch_copy_mask_to_alpha(global float4 *in,
+                           global dt_iop_roi_t *roi_in,
+                           global float *mask_scaled,
+                           global dt_iop_roi_t *roi_mask_scaled,
+                           const float opacity)
 {
   const int x = get_global_id(0);
   const int y = get_global_id(1);
 
   if(x >= roi_mask_scaled->width || y >= roi_mask_scaled->height) return;
 
   const int mask_index = mad24(y, roi_mask_scaled->width, x);
-  const int dest_index
-      = mad24(y + roi_mask_scaled->y - roi_in->y, roi_in->width, x + roi_mask_scaled->x - roi_in->x);
+  const int dest_index = mad24(y + roi_mask_scaled->y - roi_in->y, roi_in->width, x + roi_mask_scaled->x - roi_in->x);
 
-  const float f = mask_scaled[mask_index] * opacity;
+  const float f = clipf(mask_scaled[mask_index] * opacity);
 
   if(f > in[dest_index].w) in[dest_index].w = f;
 }
 
 kernel void
-retouch_fill(global float4 *in, global dt_iop_roi_t *roi_in, global float *mask_scaled,
-                         global dt_iop_roi_t *roi_mask_scaled, const float opacity, const float color_x,
-                         const float color_y, const float color_z)
+retouch_fill(global float4 *in,
+             global dt_iop_roi_t *roi_in,
+             global float *mask_scaled,
+             global dt_iop_roi_t *roi_mask_scaled,
+             const float opacity,
+             const float color_x,
+             const float color_y,
+             const float color_z)
 {
   const int x = get_global_id(0);
   const int y = get_global_id(1);
 
   if(x >= roi_mask_scaled->width || y >= roi_mask_scaled->height) return;
 
   const int mask_index = mad24(y, roi_mask_scaled->width, x);
-  const int dest_index
-      = mad24(y + roi_mask_scaled->y - roi_in->y, roi_in->width, x + roi_mask_scaled->x - roi_in->x);
+  const int dest_index = mad24(y + roi_mask_scaled->y - roi_in->y, roi_in->width, x + roi_mask_scaled->x - roi_in->x);
 
   float4 fill_color = { color_x, color_y, color_z, 0.f };
-  const float f = mask_scaled[mask_index] * opacity;
+  const float f = clipf(mask_scaled[mask_index] * opacity);
   const float w = in[dest_index].w;
 
   in[dest_index] = in[dest_index] * (1.0f - f) + fill_color * f;
@@ -120,9 +136,12 @@ retouch_fill(global float4 *in, global dt_iop_roi_t *roi_in, global float *mask_
 }
 
 kernel void
-retouch_copy_buffer_to_buffer_masked(global float4 *buffer_src, global float4 *buffer_dest,
-                                                 global dt_iop_roi_t *roi_buffer_dest, global float *mask_scaled,
-                                                 global dt_iop_roi_t *roi_mask_scaled, const float opacity)
+retouch_copy_buffer_to_buffer_masked(global float4 *buffer_src,
+                                     global float4 *buffer_dest,
+                                     global dt_iop_roi_t *roi_buffer_dest,
+                                     global float *mask_scaled,
+                                     global dt_iop_roi_t *roi_mask_scaled,
+                                     const float opacity)
 {
   const int x = get_global_id(0);
   const int y = get_global_id(1);
@@ -134,7 +153,7 @@ retouch_copy_buffer_to_buffer_masked(global float4 *buffer_src, global float4 *b
   const int idx_src = mad24(y, roi_mask_scaled->width, x);
   const int idx_mask = mad24(y, roi_mask_scaled->width, x);
 
-  const float f = mask_scaled[idx_mask] * opacity;
+  const float f = clipf(mask_scaled[idx_mask] * opacity);
   const float w = buffer_dest[idx_dest].w;
 
   buffer_dest[idx_dest] = buffer_dest[idx_dest] * (1.0f - f) + buffer_src[idx_src] * f;
@@ -143,9 +162,12 @@ retouch_copy_buffer_to_buffer_masked(global float4 *buffer_src, global float4 *b
 }
 
 kernel void
-retouch_copy_image_to_buffer_masked(__read_only image2d_t buffer_src, global float4 *buffer_dest,
-                                                global dt_iop_roi_t *roi_buffer_dest, global float *mask_scaled,
-                                                global dt_iop_roi_t *roi_mask_scaled, const float opacity)
+retouch_copy_image_to_buffer_masked(__read_only image2d_t buffer_src,
+                                    global float4 *buffer_dest,
+                                    global dt_iop_roi_t *roi_buffer_dest,
+                                    global float *mask_scaled,
+                                    global dt_iop_roi_t *roi_mask_scaled,
+                                    const float opacity)
 {
   const int x = get_global_id(0);
   const int y = get_global_id(1);
@@ -156,17 +178,19 @@ retouch_copy_image_to_buffer_masked(__read_only image2d_t buffer_src, global flo
                              x + roi_mask_scaled->x - roi_buffer_dest->x);
   const int idx_mask = mad24(y, roi_mask_scaled->width, x);
 
-  const float f = mask_scaled[idx_mask] * opacity;
+  const float f = clipf(mask_scaled[idx_mask] * opacity);
   const float w = buffer_dest[idx_dest].w;
 
-  float4 pix = read_imagef(buffer_src, sampleri, (int2)(x, y));
+  float4 pix = readpixel(buffer_src, x, y);
   buffer_dest[idx_dest] = buffer_dest[idx_dest] * (1.0f - f) + pix * f;
 
   buffer_dest[idx_dest].w = w;
 }
 
 kernel void
-retouch_image_rgb2lab(global float4 *in, int width, int height)
+retouch_image_rgb2lab(global float4 *in,
+                      int width,
+                      int height)
 {
   const int x = get_global_id(0);
   const int y = get_global_id(1);
@@ -179,7 +203,9 @@ retouch_image_rgb2lab(global float4 *in, int width, int height)
 }
 
 kernel void
-retouch_image_lab2rgb(global float4 *in, int width, int height)
+retouch_image_lab2rgb(global float4 *in,
+                      int width,
+                      int height)
 {
   const int x = get_global_id(0);
   const int y = get_global_id(1);

data/kernels/retouch.cl

@@ -490,7 +490,7 @@ static inline void _compute_downsampling_kernel(const dt_interpolation_t *itor,
 }
 
 /* --------------------------------------------------------------------------
- * Sample interpolation function (see usage in iop/lens.c and iop/clipping.c)
+ * Sample interpolation function (see usage in iop/lens.c and mask distortions)
  * ------------------------------------------------------------------------*/
 
 #define MAX_KERNEL_REQ ((2 * (MAX_HALF_FILTER_WIDTH) + 3) & (~3))
@@ -516,11 +516,11 @@ float dt_interpolation_compute_sample(const dt_interpolation_t *itor,
   int ix = (int)x;
   int iy = (int)y;
 
+  float s = 0.0f;
   /* Now 2 cases, the pixel + filter width goes outside the image
    * in that case we have to use index clipping to keep all reads
    * in the input image (slow path) or we are sure it won't fall
    * outside and can do more simple code */
-  float r;
   if(ix >= (itor->width - 1)
       && iy >= (itor->width - 1)
       && ix < (width - itor->width)
@@ -533,7 +533,6 @@ float dt_interpolation_compute_sample(const dt_interpolation_t *itor,
     in = in - (itor->width - 1) * (samplestride + linestride);
 
     // Apply the kernel
-    float s = 0.f;
     for(int i = 0; i < 2 * itor->width; i++)
     {
       float h = 0.0f;
@@ -544,7 +543,7 @@ float dt_interpolation_compute_sample(const dt_interpolation_t *itor,
       s += kernelv[i] * h;
       in += linestride;
     }
-    r = s / (normh * normv);
+    s = s / (normh * normv);
   }
   else if(ix >= 0 && iy >= 0 && ix < width && iy < height)
   {
@@ -568,7 +567,6 @@ float dt_interpolation_compute_sample(const dt_interpolation_t *itor,
                            bordermode, 2 * itor->width, iy, height);
 
     // Apply the kernel
-    float s = 0.f;
     for(ssize_t i = ytap_first; i < ytap_last; i++)
     {
       const ssize_t clip_y = _clip(iy + i, 0, height - 1, bordermode);
@@ -581,19 +579,13 @@ float dt_interpolation_compute_sample(const dt_interpolation_t *itor,
       }
       s += kernelv[i] * h;
     }
-
-    r = s / (normh * normv);
-  }
-  else
-  {
-    // invalid coordinate
-    r = 0.0f;
+    s = s / (normh * normv);
   }
-  return fmaxf(0.0f, r); // make sure we don't push NaNs
+  return s; // if called for masks make sure to CLIP to avoid interpolator under/overshoots
 }
 
 /* --------------------------------------------------------------------------
- * Pixel interpolation function (see usage in iop/lens.c and iop/clipping.c)
+ * Pixel interpolation function (see usage in ashift.c)
  * ------------------------------------------------------------------------*/
 
 void dt_interpolation_compute_pixel4c(const dt_interpolation_t *itor,