retouch.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2017-2019 Edgardo Hoszowski.
    Copyright (C) 2018 Alexandre Prokoudine.
    Copyright (C) 2018-2020, 2023-2026 Aurélien PIERRE.
    Copyright (C) 2018-2022 Pascal Obry.
    Copyright (C) 2018 rawfiner.
    Copyright (C) 2019-2022 Aldric Renaudin.
    Copyright (C) 2019 Andreas Schneider.
    Copyright (C) 2019-2020, 2022 Diederik Ter Rahe.
    Copyright (C) 2019 emeikei.
    Copyright (C) 2019 luzpaz.
    Copyright (C) 2019 Tobias Ellinghaus.
    Copyright (C) 2020 Chris Elston.
    Copyright (C) 2020-2021 Hubert Kowalski.
    Copyright (C) 2020 Marco.
    Copyright (C) 2020 Mark-64.
    Copyright (C) 2020-2021 Ralf Brown.
    Copyright (C) 2020 Ulrich Pegelow.
    Copyright (C) 2021 Dan Torop.
    Copyright (C) 2021 lhietal.
    Copyright (C) 2022 Hanno Schwalm.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2022 Philipp Lutz.
    Copyright (C) 2023 Alynx Zhou.
    Copyright (C) 2025-2026 Guillaume Stutin.
    
    darktable is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    darktable is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with darktable.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifdef HAVE_CONFIG_H
#include "caches/pixelpipe_cache_alloc.h"
#include "develop/iop_profile.h"
#include "widgets/widget_settings.h"
#include "widgets/accelerators.h"
#include "common/conf.h"
#include "config.h"
#endif
#include "caches/pixelpipe_cache.h"
#include "common/hash.h"
#include "control/control.h"
#include "widgets/bauhaus.h"
#include "system/macros.h"
#include "system/openmp.h"
#include "system/target_clones.h"
#include "system/mem_alloc.h"
#include "system/simd.h"
#include "common/logging.h"
#include "common/module_versioning.h"
#include "pixel/bilateral.h"
#include "pixel/bilateralcl.h"
#include "common/colorspaces_inline_conversions.h"
#include "pixel/dwt.h"
#include "pixel/gaussian.h"
#include "pixel/heal.h"
#include "common/imagebuf.h"
#include "common/opencl.h"
#include "develop/blend.h"
#include "develop/blend_gui.h"
#include "develop/imageop_math.h"
#include "develop/imageop_gui.h"
#include "develop/masks.h"
#include "develop/masks_group.h"
#include "develop/masks_gui.h"
#include "develop/tiling.h"
#include "gui/actions/menu.h"
#include "iop/iop_api.h"
 
#include "gui/color_picker_proxy.h"
#include <stdlib.h>
#include "widgets/label.h"
#include "gui/screen_metrics.h"
#include "control/signal.h"
 
// this is the version of the modules parameters,
// and includes version information about compile-time dt
DT_MODULE_INTROSPECTION(4, dt_iop_retouch_params_t)
 
#define RETOUCH_NO_FORMS 300
#define RETOUCH_MAX_SCALES 15
#define RETOUCH_NO_SCALES (RETOUCH_MAX_SCALES + 2)
 
#define RETOUCH_PREVIEW_LVL_MIN -3.0f
#define RETOUCH_PREVIEW_LVL_MAX 3.0f
 
typedef enum dt_iop_retouch_drag_types_t {
  DT_IOP_RETOUCH_WDBAR_DRAG_TOP = 1,
  DT_IOP_RETOUCH_WDBAR_DRAG_BOTTOM = 2,
} dt_iop_retouch_drag_types_t;
 
typedef enum dt_iop_retouch_fill_modes_t {
  DT_IOP_RETOUCH_FILL_ERASE = 0, // $DESCRIPTION: "Erase"
  DT_IOP_RETOUCH_FILL_COLOR = 1  // $DESCRIPTION: "Color"
} dt_iop_retouch_fill_modes_t;
 
// How the heal algorithm carries the source's texture over to the destination level,
// see dt_heal_domain_t. Edits made before the square-root algorithm existed keep the linear one.
typedef enum dt_iop_retouch_heal_algorithm_t {
  DT_IOP_RETOUCH_HEAL_LINEAR = 0, // $DESCRIPTION: "Linear"
  DT_IOP_RETOUCH_HEAL_SQRT = 1    // $DESCRIPTION: "Square root"
} dt_iop_retouch_heal_algorithm_t;
 
typedef enum dt_iop_retouch_blur_types_t {
  DT_IOP_RETOUCH_BLUR_GAUSSIAN = 0, // $DESCRIPTION: "Gaussian"
  DT_IOP_RETOUCH_BLUR_BILATERAL = 1 // $DESCRIPTION: "Bilateral"
} dt_iop_retouch_blur_types_t;
 
typedef enum dt_iop_retouch_algo_type_t {
  DT_IOP_RETOUCH_NONE = 0,  // $DESCRIPTION: "Unused"
  DT_IOP_RETOUCH_CLONE = 1, // $DESCRIPTION: "Clone"
  DT_IOP_RETOUCH_HEAL = 2,  // $DESCRIPTION: "Heal"
  DT_IOP_RETOUCH_BLUR = 3,  // $DESCRIPTION: "Blur"
  DT_IOP_RETOUCH_FILL = 4   // $DESCRIPTION: "Fill"
} dt_iop_retouch_algo_type_t;
 
typedef struct dt_iop_retouch_form_data_t
{
  int formid; // from masks, form->formid
  int scale;  // 0==original image; 1..RETOUCH_MAX_SCALES==scale; RETOUCH_MAX_SCALES+1==residual
  dt_iop_retouch_algo_type_t algorithm;  // clone, heal, blur, fill
 
  dt_iop_retouch_blur_types_t blur_type; // gaussian, bilateral
  float blur_radius;                     // radius for blur algorithm
 
  dt_iop_retouch_fill_modes_t fill_mode; // mode for fill algorithm, erase or fill with color
  float fill_color[3];                   // color for fill algorithm
  float fill_brightness;                 // value to be added to the color
  int distort_mode; // module v1 => 1, otherwise 2. mode 1 as issues if there's distortion before this module
} dt_iop_retouch_form_data_t;
 
typedef struct retouch_user_data_t
{
  dt_iop_module_t *self;
  const dt_dev_pixelpipe_t *pipe;
  const dt_dev_pixelpipe_iop_t *piece;
  dt_iop_roi_t roi;
  int display_scale;
  int mask_display;
  int suppress_mask;
  // Accumulated across every wavelet scale of one render, reported once by the caller of
  // dwt_decompose(). NULL `stats` means -d perf did not ask. See rt_memo_stats_t.
  struct rt_memo_stats_t *stats;
} retouch_user_data_t;
 
typedef struct dt_iop_retouch_params_t
{
  dt_iop_retouch_form_data_t rt_forms[RETOUCH_NO_FORMS]; // array of masks index and additional data
 
  dt_iop_retouch_algo_type_t algorithm; // $DEFAULT: DT_IOP_RETOUCH_HEAL clone, heal, blur, fill
 
  int num_scales;       // $DEFAULT: 0 number of wavelets scales
  int curr_scale;       // $DEFAULT: 0 current wavelet scale
  int merge_from_scale; // $DEFAULT: 0
 
  float preview_levels[3];
 
  dt_iop_retouch_blur_types_t blur_type; // $DEFAULT: DT_IOP_RETOUCH_BLUR_GAUSSIAN $DESCRIPTION: "Blur type" gaussian, bilateral
  float blur_radius; // $MIN: 0.1 $MAX: 200.0 $DEFAULT: 10.0 $DESCRIPTION: "Blur radius" radius for blur algorithm
 
  dt_iop_retouch_fill_modes_t fill_mode; // $DEFAULT: DT_IOP_RETOUCH_FILL_ERASE $DESCRIPTION: "Fill mode" mode for fill algorithm, erase or fill with color
  float fill_color[3];   // $DEFAULT: 0.0 color for fill algorithm
  float fill_brightness; // $MIN: -1.0 $MAX: 1.0 $DESCRIPTION: "Brightness" value to be added to the color
  int max_heal_iter;     // $DEFAULT: 2000 $DESCRIPTION: "Max_iter" numbe of iteration for heal algorithm
  dt_iop_retouch_heal_algorithm_t heal_algorithm; // $DEFAULT: DT_IOP_RETOUCH_HEAL_SQRT $DESCRIPTION: "Heal algorithm"
} dt_iop_retouch_params_t;
 
typedef struct dt_iop_retouch_gui_data_t
{
  int copied_scale; // scale to be copied to another scale
  int mask_display; // should we expose masks?
  int suppress_mask;         // do not process masks
  int display_wavelet_scale; // display current wavelet scale
  int displayed_wavelet_scale; // was display wavelet scale already used?
  int preview_auto_levels;   // should we calculate levels automatically?
  float preview_levels[3];   // values for the levels
  int first_scale_visible;   // 1st scale visible at current zoom level
 
  GtkLabel *label_form;                                                      // display number of forms
  GtkLabel *label_form_selected;                                             // display number of forms selected
  GtkWidget *bt_edit_masks, *bt_polygon, *bt_circle, *bt_ellipse, *bt_brush; // shapes
  GtkWidget *bt_clone, *bt_heal, *bt_blur, *bt_fill;                         // algorithms
  GtkWidget *bt_showmask, *bt_suppress;                                      // suppress & show masks
 
  GtkWidget *wd_bar; // wavelet decompose bar
  GtkLabel *lbl_num_scales;
  GtkLabel *lbl_curr_scale;
  GtkLabel *lbl_merge_from_scale;
  float wdbar_mouse_x, wdbar_mouse_y;
  int curr_scale; // scale box under mouse
  gboolean is_dragging;
  gboolean upper_cursor; // mouse on merge from scale cursor
  gboolean lower_cursor; // mouse on num scales cursor
  gboolean upper_margin; // mouse on the upper band
  gboolean lower_margin; // mouse on the lower band
 
  GtkWidget *bt_display_wavelet_scale; // show decomposed scale
 
  GtkWidget *bt_copy_scale; // copy all shapes from one scale to another
  GtkWidget *bt_paste_scale;
 
  GtkWidget *vbox_preview_scale;
 
  GtkDarktableGradientSlider *preview_levels_gslider;
 
  GtkWidget *bt_auto_levels;
 
  GtkWidget *vbox_blur;
  GtkWidget *cmb_blur_type;
  GtkWidget *sl_blur_radius;
 
  GtkWidget *vbox_fill;
  GtkWidget *hbox_color_pick;
  GtkWidget *colorpick;   // select a specific color
  GtkWidget *colorpicker; // pick a color from the picture
 
  GtkWidget *cmb_fill_mode;
  GtkWidget *cmb_heal_algorithm;
  GtkWidget *sl_fill_brightness;
 
  GtkWidget *sl_mask_opacity; // draw mask opacity
} dt_iop_retouch_gui_data_t;
 
typedef struct dt_iop_retouch_params_t dt_iop_retouch_data_t;
 
typedef struct dt_iop_retouch_global_data_t
{
  int kernel_retouch_clear_alpha;
  int kernel_retouch_copy_alpha;
  int kernel_retouch_copy_buffer_to_buffer;
  int kernel_retouch_copy_buffer_to_image;
  int kernel_retouch_fill;
  int kernel_retouch_copy_image_to_buffer_masked;
  int kernel_retouch_copy_buffer_to_buffer_masked;
  int kernel_retouch_image_rgb2lab;
  int kernel_retouch_image_lab2rgb;
  int kernel_retouch_copy_mask_to_alpha;
} dt_iop_retouch_global_data_t;
 
 
// this returns a translatable name
const char *name()
{
  return _("re_touch");
}
 
const char *aliases()
{
  return _("split-frequency|healing|cloning|stamp");
}
 
 
const char **description(struct dt_iop_module_t *self)
{
  return dt_iop_set_description(self, _("remove and clone spots, perform split-frequency skin editing"),
                                      _("corrective"),
                                      _("linear, RGB, scene-referred"),
                                      _("geometric and frequential, RGB"),
                                      _("linear, RGB, scene-referred"));
}
 
int default_group()
{
  return IOP_GROUP_REPAIR;
}
 
int flags()
{
  return IOP_FLAGS_SUPPORTS_BLENDING | IOP_FLAGS_NO_MASKS | IOP_FLAGS_INTERNAL_MASKS;
}
 
int default_colorspace(dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece)
{
  return IOP_CS_RGB;
}
 
static int rt_shape_is_being_added(dt_iop_module_t *self, const int shape_type);
 
// No new params version before Ansel 1.0: v4 is the last one until then.
// New params are appended to v4 instead.
int legacy_params(dt_iop_module_t *self, const void *const old_params, const int old_version, void *new_params,
                  const int new_version)
{
  if(old_version == 1 && new_version == 4)
  {
    typedef struct dt_iop_retouch_form_data_v1_t
    {
      int formid; // from masks, form->formid
      int scale;  // 0==original image; 1..RETOUCH_MAX_SCALES==scale; RETOUCH_MAX_SCALES+1==residual
      dt_iop_retouch_algo_type_t algorithm; // clone, heal, blur, fill
 
      dt_iop_retouch_blur_types_t blur_type; // gaussian, bilateral
      float blur_radius;                     // radius for blur algorithm
 
      dt_iop_retouch_fill_modes_t fill_mode; // mode for fill algorithm, erase or fill with color
      float fill_color[3];                   // color for fill algorithm
      float fill_brightness;                 // value to be added to the color
    } dt_iop_retouch_form_data_v1_t;
    typedef struct dt_iop_retouch_params_v1_t
    {
      dt_iop_retouch_form_data_v1_t rt_forms[RETOUCH_NO_FORMS]; // array of masks index and additional data
 
      dt_iop_retouch_algo_type_t algorithm; // $DEFAULT: DT_IOP_RETOUCH_HEAL clone, heal, blur, fill
 
      int num_scales;       // $DEFAULT: 0 number of wavelets scales
      int curr_scale;       // $DEFAULT: 0 current wavelet scale
      int merge_from_scale; // $DEFAULT: 0
 
      float preview_levels[3];
 
      dt_iop_retouch_blur_types_t blur_type; // $DEFAULT: DT_IOP_RETOUCH_BLUR_GAUSSIAN $DESCRIPTION: "blur type"
                                             // gaussian, bilateral
      float blur_radius; // $MIN: 0.1 $MAX: 200.0 $DEFAULT: 10.0 $DESCRIPTION: "blur radius" radius for blur
                         // algorithm
 
      dt_iop_retouch_fill_modes_t fill_mode; // $DEFAULT: DT_IOP_RETOUCH_FILL_ERASE $DESCRIPTION: "fill mode" mode
                                             // for fill algorithm, erase or fill with color
      float fill_color[3];                   // $DEFAULT: 0.0 color for fill algorithm
      float fill_brightness; // $MIN: -1.0 $MAX: 1.0 $DESCRIPTION: "brightness" value to be added to the color
    } dt_iop_retouch_params_v1_t;
 
    dt_iop_retouch_params_v1_t *o = (dt_iop_retouch_params_v1_t *)old_params;
    dt_iop_retouch_params_t *n = (dt_iop_retouch_params_t *)new_params;
    dt_iop_retouch_params_t *d = (dt_iop_retouch_params_t *)self->default_params;
 
    *n = *d; // start with a fresh copy of default parameters
    for(int i = 0; i < RETOUCH_NO_FORMS; i++)
    {
      dt_iop_retouch_form_data_v1_t of = o->rt_forms[i];
      n->rt_forms[i].algorithm = of.algorithm;
      n->rt_forms[i].blur_radius = of.blur_radius;
      n->rt_forms[i].blur_type = of.blur_type;
      n->rt_forms[i].distort_mode = 1;
      n->rt_forms[i].fill_brightness = of.fill_brightness;
      n->rt_forms[i].fill_color[0] = of.fill_color[0];
      n->rt_forms[i].fill_color[1] = of.fill_color[1];
      n->rt_forms[i].fill_color[2] = of.fill_color[2];
      n->rt_forms[i].fill_mode = of.fill_mode;
      n->rt_forms[i].formid = of.formid;
      n->rt_forms[i].scale = of.scale;
    }
    n->algorithm = o->algorithm;
    n->blur_radius = o->blur_radius;
    n->blur_type = o->blur_type;
    n->curr_scale = o->curr_scale;
    n->fill_brightness = o->fill_brightness;
    n->fill_color[0] = o->fill_color[0];
    n->fill_color[1] = o->fill_color[1];
    n->fill_color[2] = o->fill_color[2];
    n->fill_mode = o->fill_mode;
    n->merge_from_scale = o->merge_from_scale;
    n->num_scales = o->num_scales;
    n->preview_levels[0] = o->preview_levels[0];
    n->preview_levels[1] = o->preview_levels[1];
    n->preview_levels[2] = o->preview_levels[2];
 
    n->max_heal_iter = 1000;
    n->heal_algorithm = DT_IOP_RETOUCH_HEAL_LINEAR;
 
    return 0;
  }
  if(old_version == 2 && new_version == 4)
  {
    typedef struct dt_iop_retouch_params_v2_t
    {
      dt_iop_retouch_form_data_t rt_forms[RETOUCH_NO_FORMS]; // array of masks index and additional data
 
      dt_iop_retouch_algo_type_t algorithm; // $DEFAULT: DT_IOP_RETOUCH_HEAL clone, heal, blur, fill
 
      int num_scales;       // $DEFAULT: 0 number of wavelets scales
      int curr_scale;       // $DEFAULT: 0 current wavelet scale
      int merge_from_scale; // $DEFAULT: 0
 
      float preview_levels[3];
 
      dt_iop_retouch_blur_types_t blur_type; // $DEFAULT: DT_IOP_RETOUCH_BLUR_GAUSSIAN $DESCRIPTION: "blur type" gaussian, bilateral
      float blur_radius; // $MIN: 0.1 $MAX: 200.0 $DEFAULT: 10.0 $DESCRIPTION: "blur radius" radius for blur algorithm
 
      dt_iop_retouch_fill_modes_t fill_mode; // $DEFAULT: DT_IOP_RETOUCH_FILL_ERASE $DESCRIPTION: "fill mode" mode for fill algorithm, erase or fill with color
      float fill_color[3];   // $DEFAULT: 0.0 color for fill algorithm
      float fill_brightness; // $MIN: -1.0 $MAX: 1.0 $DESCRIPTION: "brightness" value to be added to the color
    } dt_iop_retouch_params_v2_t;
 
    dt_iop_retouch_params_v2_t *o = (dt_iop_retouch_params_v2_t *)old_params;
    dt_iop_retouch_params_t *n = (dt_iop_retouch_params_t *)new_params;
    dt_iop_retouch_params_t *d = (dt_iop_retouch_params_t *)self->default_params;
 
    *n = *d; // start with a fresh copy of default parameters
 
    memcpy(n, o, sizeof(dt_iop_retouch_params_v2_t));
 
    n->max_heal_iter = 1000;
    n->heal_algorithm = DT_IOP_RETOUCH_HEAL_LINEAR;
 
    return 0;
  }
  if(old_version == 3 && new_version == 4)
  {
    // v3 is v4 without the trailing heal_algorithm
    const size_t v3_size = offsetof(dt_iop_retouch_params_t, heal_algorithm);
    dt_iop_retouch_params_t *n = (dt_iop_retouch_params_t *)new_params;
    const dt_iop_retouch_params_t *d = (dt_iop_retouch_params_t *)self->default_params;
 
    *n = *d;
    memcpy(n, old_params, v3_size);
    n->heal_algorithm = DT_IOP_RETOUCH_HEAL_LINEAR;
 
    return 0;
  }
  return 1;
}
 
static int rt_get_index_from_formid(const dt_iop_retouch_params_t *p, const int formid)
{
  int index = -1;
  if(formid > 0)
  {
    int i = 0;
 
    while(index == -1 && i < RETOUCH_NO_FORMS)
    {
      if(p->rt_forms[i].formid == formid) index = i;
      i++;
    }
  }
  return index;
}
 
static int rt_get_selected_shape_id(const dt_iop_module_t *self)
{
  if(IS_NULL_PTR(self) || IS_NULL_PTR(self->dev)) return 0;
 
  const dt_masks_form_gui_t *gui = self->dev->form_gui;
  const dt_masks_form_t *visible_form = dt_masks_get_visible_form(self->dev);
  if(IS_NULL_PTR(gui) || IS_NULL_PTR(visible_form) || !(visible_form->type & DT_MASKS_GROUP)) return 0;
 
  const dt_masks_form_group_t *selected_group_entry
      = dt_masks_form_get_selected_group_live(visible_form, gui);
  return selected_group_entry ? selected_group_entry->formid : 0;
}
 
static dt_masks_form_group_t *rt_get_mask_point_group(dt_iop_module_t *self, int formid)
{
  dt_masks_form_group_t *form_point_group = NULL;
 
  const dt_develop_blend_params_t *bp = self->blend_params;
  if(IS_NULL_PTR(bp)) return form_point_group;
 
  const dt_masks_form_t *grp = dt_masks_get_from_id(self->dev, bp->mask_id);
  if(!IS_NULL_PTR(grp) && (grp->type & DT_MASKS_GROUP))
  {
    for(const GList *forms = grp->points; forms; forms = g_list_next(forms))
    {
      dt_masks_form_group_t *grpt = (dt_masks_form_group_t *)forms->data;
      if(grpt->formid == formid)
      {
        form_point_group = grpt;
        break;
      }
    }
  }
 
  return form_point_group;
}
 
static float rt_get_shape_opacity(dt_iop_module_t *self, const int formid)
{
  float opacity = 0.f;
 
  dt_masks_form_group_t *grpt = rt_get_mask_point_group(self, formid);
  if(grpt) opacity = grpt->opacity;
 
  return opacity;
}
 
static void rt_display_selected_fill_color(dt_iop_retouch_gui_data_t *g, dt_iop_retouch_params_t *p)
{
  GdkRGBA c
      = (GdkRGBA){.red = p->fill_color[0], .green = p->fill_color[1], .blue = p->fill_color[2], .alpha = 1.0 };
  gtk_color_chooser_set_rgba(GTK_COLOR_CHOOSER(g->colorpick), &c);
}
 
static void rt_show_hide_controls(const dt_iop_module_t *self)
{
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
 
  switch(p->algorithm)
  {
    case DT_IOP_RETOUCH_HEAL:
      gtk_widget_hide(GTK_WIDGET(g->vbox_blur));
      gtk_widget_hide(GTK_WIDGET(g->vbox_fill));
      break;
    case DT_IOP_RETOUCH_BLUR:
      gtk_widget_show(GTK_WIDGET(g->vbox_blur));
      gtk_widget_hide(GTK_WIDGET(g->vbox_fill));
      break;
    case DT_IOP_RETOUCH_FILL:
      gtk_widget_hide(GTK_WIDGET(g->vbox_blur));
      gtk_widget_show(GTK_WIDGET(g->vbox_fill));
      if(p->fill_mode == DT_IOP_RETOUCH_FILL_COLOR)
        gtk_widget_show(GTK_WIDGET(g->hbox_color_pick));
      else
        gtk_widget_hide(GTK_WIDGET(g->hbox_color_pick));
      break;
    case DT_IOP_RETOUCH_CLONE:
    default:
      gtk_widget_hide(GTK_WIDGET(g->vbox_blur));
      gtk_widget_hide(GTK_WIDGET(g->vbox_fill));
      break;
  }
 
  if(g->display_wavelet_scale)
    gtk_widget_show(GTK_WIDGET(g->vbox_preview_scale));
  else
    gtk_widget_hide(GTK_WIDGET(g->vbox_preview_scale));
 
  const dt_masks_form_t *form = NULL;
  const int selected_formid = rt_get_selected_shape_id(self);
  if(selected_formid > 0)
    form = dt_masks_get_from_id(self->dev, selected_formid);
  if(!IS_NULL_PTR(form))
    gtk_widget_show(GTK_WIDGET(g->sl_mask_opacity));
  else
    gtk_widget_hide(GTK_WIDGET(g->sl_mask_opacity));
}
 
static void rt_display_selected_shapes_lbl(dt_develop_t *dev, dt_iop_retouch_gui_data_t *g)
{
  const int selected_formid = rt_get_selected_shape_id(dev->gui_module);
  const dt_masks_form_t *form = selected_formid > 0
                                ? dt_masks_get_from_id(dev, selected_formid)
                                : NULL;
  if(!IS_NULL_PTR(form))
    gtk_label_set_text(g->label_form_selected, form->name);
  else
    gtk_label_set_text(g->label_form_selected, _("none"));
}
 
static int rt_get_selected_shape_index(dt_develop_t *dev, const dt_iop_retouch_params_t *p)
{
  const int selected_formid = rt_get_selected_shape_id(dev->gui_module);
  return rt_get_index_from_formid(p, selected_formid);
}
 
static void rt_load_shape_algo_in_gui(dt_iop_module_t *self, const int form_selected_id)
{
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  dt_gui_freeze_begin();
 
  gboolean selection_changed = FALSE;
 
  const int index = rt_get_index_from_formid(p, form_selected_id);
  if(index >= 0)
  {
    const dt_iop_retouch_form_data_t *const selected_form = &p->rt_forms[index];
    dt_bauhaus_slider_set(g->sl_mask_opacity, rt_get_shape_opacity(self, selected_form->formid));
 
    if(selected_form->algorithm == DT_IOP_RETOUCH_BLUR)
    {
      p->blur_type = selected_form->blur_type;
      p->blur_radius = selected_form->blur_radius;
 
      dt_bauhaus_combobox_set(g->cmb_blur_type, p->blur_type);
      dt_bauhaus_slider_set(g->sl_blur_radius, p->blur_radius);
 
      selection_changed = TRUE;
    }
    else if(selected_form->algorithm == DT_IOP_RETOUCH_FILL)
    {
      p->fill_mode = selected_form->fill_mode;
      p->fill_brightness = selected_form->fill_brightness;
      p->fill_color[0] = selected_form->fill_color[0];
      p->fill_color[1] = selected_form->fill_color[1];
      p->fill_color[2] = selected_form->fill_color[2];
 
      dt_bauhaus_slider_set(g->sl_fill_brightness, p->fill_brightness);
      dt_bauhaus_combobox_set(g->cmb_fill_mode, p->fill_mode);
      rt_display_selected_fill_color(g, p);
 
      selection_changed = TRUE;
    }
 
    if(p->algorithm != selected_form->algorithm)
    {
      p->algorithm = selected_form->algorithm;
 
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_clone), (p->algorithm == DT_IOP_RETOUCH_CLONE));
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_heal), (p->algorithm == DT_IOP_RETOUCH_HEAL));
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_blur), (p->algorithm == DT_IOP_RETOUCH_BLUR));
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_fill), (p->algorithm == DT_IOP_RETOUCH_FILL));
 
      selection_changed = TRUE;
    }
  }
 
  if(selection_changed) rt_show_hide_controls(self);
 
  rt_display_selected_shapes_lbl(self->dev, g);
 
  if(index >= 0)
    gtk_widget_show(GTK_WIDGET(g->sl_mask_opacity));
  else
    gtk_widget_hide(GTK_WIDGET(g->sl_mask_opacity));
 
  dt_gui_freeze_end();
}
 
//---------------------------------------------------------------------------------
// helpers
//---------------------------------------------------------------------------------
 
static void rt_masks_form_change_opacity(dt_iop_module_t *self, int formid, float opacity)
{
  const dt_develop_blend_params_t *bp = self->blend_params;
  if(IS_NULL_PTR(bp)) return;
 
  /* Retouch keeps a 5% floor of its own, applied BEFORE the call: a fully transparent clone or
   * heal is indistinguishable from a deleted one in this module's list, so it never offers 0 the
   * way a generic mask does. The API clamps to [0;1] and would accept it. */
  dt_masks_member_t member = { 0 };
  const dt_masks_result_t result = dt_masks_group_set_member_opacity(self->dev, bp->mask_id, formid,
                                                                     CLAMP(opacity, 0.05f, 1.0f), &member);
  if(result != DT_MASKS_OK && result != DT_MASKS_UNCHANGED) return;
 
  dt_conf_set_float("plugins/darkroom/masks/opacity", member.opacity);
 
  /* Only a real change earns a history step. Re-setting the opacity a shape already has used to
   * push an undo entry that undid nothing. */
  if(result == DT_MASKS_OK) dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
 
static float rt_masks_form_get_opacity(dt_iop_module_t *self, int formid)
{
  dt_masks_form_group_t *grpt = rt_get_mask_point_group(self, formid);
  if(!IS_NULL_PTR(grpt))
    return grpt->opacity;
  else
    return 1.0f;
}
 
static void rt_paste_forms_from_scale(dt_iop_retouch_params_t *p, const int source_scale, const int dest_scale)
{
  if(source_scale != dest_scale && source_scale >= 0 && dest_scale >= 0)
  {
    for(int i = 0; i < RETOUCH_NO_FORMS; i++)
    {
      if(p->rt_forms[i].scale == source_scale) p->rt_forms[i].scale = dest_scale;
    }
  }
}
 
static int rt_allow_create_form(dt_iop_module_t *self)
{
  int allow = 1;
 
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  if(!IS_NULL_PTR(p))
  {
    allow = (p->rt_forms[RETOUCH_NO_FORMS - 1].formid == 0);
  }
  return allow;
}
 
static void rt_show_forms_for_current_scale(dt_iop_module_t *self)
{
  if(!self->enabled || self->dev->gui_module != self || self->dev->form_gui->creation)
    return;
 
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  dt_iop_gui_blend_data_t *bd = (dt_iop_gui_blend_data_t *)self->gui->blend_data;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
  if(IS_NULL_PTR(bd)) return;
 
  const int scale = p->curr_scale;
  int count = 0;
 
  // Check if there is at least one shape on this scale
  for(int i = 0; i < RETOUCH_NO_FORMS && count == 0; i++)
  {
    if(p->rt_forms[i].formid != 0 && p->rt_forms[i].scale == scale) count++;
  }
 
  // If a shape was found on this scale, make the cut shapes button sensitive
  gtk_widget_set_sensitive(g->bt_copy_scale, count > 0);
 
  // if no shapes on this scale, we hide all
  if(bd->masks_shown == DT_MASKS_EDIT_OFF || count == 0)
  {
    dt_masks_change_form_gui(self->dev, NULL);
 
    if(g)
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_edit_masks),
                                   (bd->masks_shown != DT_MASKS_EDIT_OFF)
                                       && (self->dev->gui_module == self));
 
    dt_control_queue_redraw_center();
    return;
  }
 
  // else, we create a new from group with the shapes and display it
  dt_masks_form_t *grp = dt_masks_create_ext(self->dev, DT_MASKS_GROUP);
  const int grid = self->blend_params->mask_id;
 
  for(int i = 0; i < RETOUCH_NO_FORMS; i++)
  {
    if(p->rt_forms[i].scale == scale)
    {
      const int formid = p->rt_forms[i].formid;
      dt_masks_form_t *form = dt_masks_get_from_id(self->dev, formid);
      if(IS_NULL_PTR(form)) continue;
      
      dt_masks_group_add_form_with_state(self->dev, grp, form, grid,
                                         DT_MASKS_STATE_USE | DT_MASKS_STATE_UNION, 1.0f);
    }
  }
 
  dt_masks_form_t *grp_dest = dt_masks_create_ext(self->dev, DT_MASKS_GROUP);
  grp_dest->formid = 0;
  dt_masks_group_ungroup(self->dev, grp_dest, grp);
  dt_masks_change_form_gui(self->dev, grp_dest);
  self->dev->form_gui->edit_mode = bd->masks_shown;
 
  if(g)
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_edit_masks),
                                 (bd->masks_shown != DT_MASKS_EDIT_OFF) && (self->dev->gui_module == self));
 
  dt_control_queue_redraw_center();
}
 
// called if a shape is added or deleted
static void rt_resynch_params(struct dt_iop_module_t *self, dt_iop_retouch_params_t *p, GList *forms_list)
{
  dt_develop_blend_params_t *bp = self->blend_params;
  if(IS_NULL_PTR(p) || IS_NULL_PTR(bp)) return;
 
  // Create a temporary array to store form data and initialize it to zero
  dt_iop_retouch_form_data_t forms_d[RETOUCH_NO_FORMS];
  memset(forms_d, 0, sizeof(dt_iop_retouch_form_data_t) * RETOUCH_NO_FORMS);
 
  // we go through all forms in blend params
  dt_masks_form_t *grp = dt_masks_get_from_id_ext(forms_list, bp->mask_id);
  if(IS_NULL_PTR(grp) || !(grp->type & DT_MASKS_GROUP))
    return;
  
  int new_form_index = 0;
  // For each form in the group, we search if it already exists in the params array,
  // if it does we copy it, if not we add it to the end of the array
  for(GList *forms = grp->points; (new_form_index < RETOUCH_NO_FORMS) && forms; forms = g_list_next(forms))
  {
    dt_masks_form_group_t *grpt = (dt_masks_form_group_t *)forms->data;
    if(IS_NULL_PTR(grpt)) return;
    
    const int formid = grpt->formid;
 
    // search for the form index in the shapes array
    const int form_index = rt_get_index_from_formid(p, formid);
 
    // if it exists, copy it to the new array
    if(form_index >= 0)
    {
      forms_d[new_form_index] = p->rt_forms[form_index];
    }
    else
    {
      // if it does not exists, add it to the new array
      const dt_masks_form_t *parent_form = dt_masks_get_from_id_ext(forms_list, formid);
      if(IS_NULL_PTR(parent_form)) continue;
      
      forms_d[new_form_index].formid = formid;
      forms_d[new_form_index].scale = p->curr_scale;
      forms_d[new_form_index].algorithm = p->algorithm;
      forms_d[new_form_index].distort_mode = 2;
 
      switch(forms_d[new_form_index].algorithm)
      {
        case DT_IOP_RETOUCH_BLUR:
          forms_d[new_form_index].blur_type = p->blur_type;
          forms_d[new_form_index].blur_radius = p->blur_radius;
          break;
        case DT_IOP_RETOUCH_FILL:
          forms_d[new_form_index].fill_mode = p->fill_mode;
          forms_d[new_form_index].fill_color[0] = p->fill_color[0];
          forms_d[new_form_index].fill_color[1] = p->fill_color[1];
          forms_d[new_form_index].fill_color[2] = p->fill_color[2];
          forms_d[new_form_index].fill_brightness = p->fill_brightness;
          break;
        default:
          break;
      }
    }
    new_form_index++; 
  }
 
  // we reaffect params
  for(int i = 0; i < RETOUCH_NO_FORMS; i++)
  {
    p->rt_forms[i] = forms_d[i];
  }
}
 
void post_history_commit(dt_iop_module_t *self)
{
  // When drawing events are finished, they commit the shapes to dev->forms
  // then commit to history, where dev->forms is are copied to hist->forms.
  // This is where we need to catch the new masks
  // to sync them with our params here.
 
  // TODO: share this code with gui_update()
  dt_pthread_rwlock_rdlock(&self->dev->masks_mutex);
  rt_resynch_params(self, (dt_iop_retouch_params_t *)self->params, self->dev->forms);
  dt_pthread_rwlock_unlock(&self->dev->masks_mutex);
 
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
  if(IS_NULL_PTR(g)) return;
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_circle), rt_shape_is_being_added(self, DT_MASKS_CIRCLE));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_polygon), rt_shape_is_being_added(self, DT_MASKS_POLYGON));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_ellipse), rt_shape_is_being_added(self, DT_MASKS_ELLIPSE));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_brush), rt_shape_is_being_added(self, DT_MASKS_BRUSH));
 
  // Get the total form count and display it in the module
  const dt_masks_form_t *grp = dt_masks_get_from_id(self->dev, self->blend_params->mask_id);
  guint nb = 0;
  if(grp && (grp->type & DT_MASKS_GROUP)) nb = g_list_length(grp->points);
  gchar *str = g_strdup_printf("%d", nb);
  gtk_label_set_text(g->label_form, str);
  dt_free(str);
 
  //only toggle shape show button if shapes exist
  if(!IS_NULL_PTR(grp) && (grp->type & DT_MASKS_GROUP) && grp->points)
  {
    dt_iop_gui_blend_data_t *bd = (dt_iop_gui_blend_data_t *)self->gui->blend_data;
    if(IS_NULL_PTR(bd)) return;
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_edit_masks),
                                 (bd->masks_shown != DT_MASKS_EDIT_OFF) && (self->dev->gui_module == self));
  }
  else
  {
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_edit_masks), FALSE);
  }
}
 
static void rt_masks_point_denormalize(const dt_dev_pixelpipe_t *pipe, const dt_iop_roi_t *roi,
                                       const float *points,
                                       size_t points_count, float *new)
{
  const float scalex = pipe->iwidth * roi->scale, scaley = pipe->iheight * roi->scale;
 
  for(size_t i = 0; i < points_count * 2; i += 2)
  {
    new[i] = points[i] * scalex;
    new[i + 1] = points[i + 1] * scaley;
  }
}
 
/* What one planning pass or one render did with the memo, and what the algorithms cost.
 *
 * This exists for the drag case, which nothing else reports: moving a shape recomputes this
 * module and everything under it with the whole upstream served from the cache, and neither the
 * pipeline's own `processed \`Retouch'` line nor the per-shape `[masks]` timings say which part
 * of that frame went where -- the pipeline line does not cover modify_roi_in() at all, and that
 * is where most of the cost used to sit. Counted only under `-d perf`: `ctx->stats` is NULL
 * otherwise and every site below is one test. */
typedef struct rt_memo_stats_t
{
  int boxes_hit;         // a shape's area or source area answered from the memo
  int boxes_computed;    // the same, rasterised because the memo had no answer
  int masks_hit;         // its mask likewise answered from the memo
  int masks_rasterised;  // and likewise rasterised
  int shapes_applied;    // members that reached an algorithm
  double algo_seconds;   // time inside clone / heal / blur / fill
} rt_memo_stats_t;
 
/* The three things every one of these functions needs and none of them writes: the module, the
 * run it belongs to and its node. They always travel together, so they travel as one -- and the
 * counters with them, which is what keeps them out of every signature. */
typedef struct rt_masks_ctx_t
{
  const dt_iop_module_t *self;
  const dt_dev_pixelpipe_t *pipe;
  const dt_dev_pixelpipe_iop_t *piece;
  rt_memo_stats_t *stats; // NULL unless -d perf asked for the count
} rt_masks_ctx_t;
 
// TRUE when the timings below are wanted at all; building the counters otherwise is waste.
static inline gboolean rt_perf_enabled(void)
{
  return (dt_get_debug_flags() & DT_DEBUG_PERF) == DT_DEBUG_PERF;
}
 
static int rt_masks_point_calc_delta(const rt_masks_ctx_t *const ctx, const dt_iop_roi_t *roi,
                                     const float *target, const float *source, float *dx, float *dy,
                                     const int distort_mode)
{
  // if distort_mode==1 we don't scale at the right place, hence false positions if there's distortion before this
  // module. we keep it for backward compatibility only. all new forms have distort_mode==2
  dt_boundingbox_t points;
  if(distort_mode == 1)
  {
    rt_masks_point_denormalize(ctx->pipe, roi, target, 1, points);
    rt_masks_point_denormalize(ctx->pipe, roi, source, 1, points + 2);
  }
  else
  {
    points[0] = target[0] * ctx->pipe->iwidth;
    points[1] = target[1] * ctx->pipe->iheight;
    points[2] = source[0] * ctx->pipe->iwidth;
    points[3] = source[1] * ctx->pipe->iheight;
  }
 
  const int res = dt_dev_distort_transform_plus(ctx->pipe, ctx->self->iop_order,
                                                DT_DEV_TRANSFORM_DIR_BACK_INCL, points, 2);
  if(!res) return res;
 
  if(distort_mode == 1)
  {
    *dx = points[0] - points[2];
    *dy = points[1] - points[3];
  }
  else
  {
    *dx = (points[0] - points[2]) * roi->scale;
    *dy = (points[1] - points[3]) * roi->scale;
  }
 
  return res;
}
 
/* returns (dx dy) to get from the source to the destination */
static int rt_masks_get_delta_to_destination(const rt_masks_ctx_t *const ctx, const dt_iop_roi_t *roi,
                                             dt_masks_form_t *form, float *dx, float *dy,
                                             const int distort_mode)
{
  if(IS_NULL_PTR(form) || IS_NULL_PTR(form->points)) return 0;
  int res = 0;
 
  if(form->type & DT_MASKS_POLYGON)
  {
    const dt_masks_node_polygon_t *pt = (dt_masks_node_polygon_t *)form->points->data;
    if(IS_NULL_PTR(pt)) return 0;
 
    res = rt_masks_point_calc_delta(ctx, roi, pt->node, form->source, dx, dy, distort_mode);
  }
  else if(form->type & DT_MASKS_CIRCLE)
  {
    const dt_masks_node_circle_t *pt = (dt_masks_node_circle_t *)form->points->data;
    if(IS_NULL_PTR(pt)) return 0;
 
    res = rt_masks_point_calc_delta(ctx, roi, pt->center, form->source, dx, dy, distort_mode);
  }
  else if(form->type & DT_MASKS_ELLIPSE)
  {
    const dt_masks_node_ellipse_t *pt = (dt_masks_node_ellipse_t *)form->points->data;
    if(IS_NULL_PTR(pt)) return 0;
 
    res = rt_masks_point_calc_delta(ctx, roi, pt->center, form->source, dx, dy, distort_mode);
  }
  else if(form->type & DT_MASKS_BRUSH)
  {
    const dt_masks_node_brush_t *pt = (dt_masks_node_brush_t *)form->points->data;
    if(IS_NULL_PTR(pt)) return 0;
 
    res = rt_masks_point_calc_delta(ctx, roi, pt->node, form->source, dx, dy, distort_mode);
  }
 
  return res;
}
 
static inline __attribute__((always_inline)) void rt_clamp_minmax(float levels_old[3], float levels_new[3])
{
  // left or right has changed
  if((levels_old[0] != levels_new[0] || levels_old[2] != levels_new[2]) && levels_old[1] == levels_new[1])
  {
    // if old left and right are the same just use the new values
    if(levels_old[2] != levels_old[0])
    {
      // set the new value but keep the middle proportional
      const float left = MAX(levels_new[0], RETOUCH_PREVIEW_LVL_MIN);
      const float right = MIN(levels_new[2], RETOUCH_PREVIEW_LVL_MAX);
 
      const float percentage = (levels_old[1] - levels_old[0]) / (levels_old[2] - levels_old[0]);
      levels_new[1] = left + (right - left) * percentage;
      levels_new[0] = left;
      levels_new[2] = right;
    }
  }
 
  // if all zero make it gray
  if(levels_new[0] == 0.f && levels_new[1] == 0.f && levels_new[2] == 0.f)
  {
    levels_new[0] = -1.5f;
    levels_new[1] = 0.f;
    levels_new[2] = 1.5f;
  }
 
  // check the range
  if(levels_new[2] < levels_new[0] + 0.05f * 2.f) levels_new[2] = levels_new[0] + 0.05f * 2.f;
  if(levels_new[1] < levels_new[0] + 0.05f) levels_new[1] = levels_new[0] + 0.05f;
  if(levels_new[1] > levels_new[2] - 0.05f) levels_new[1] = levels_new[2] - 0.05f;
 
  {
    // set the new value but keep the middle proportional
    const float left = MAX(levels_new[0], RETOUCH_PREVIEW_LVL_MIN);
    const float right = MIN(levels_new[2], RETOUCH_PREVIEW_LVL_MAX);
 
    const float percentage = (levels_new[1] - levels_new[0]) / (levels_new[2] - levels_new[0]);
    levels_new[1] = left + (right - left) * percentage;
    levels_new[0] = left;
    levels_new[2] = right;
  }
}
 
static int rt_shape_is_being_added(dt_iop_module_t *self, const int shape_type)
{
  int being_added = 0;
 
  if(self->dev->form_gui && dt_masks_get_visible_form(self->dev)
     && (self->dev->form_gui->creation && self->dev->form_gui->creation_module == self))
  {
    if(dt_masks_get_visible_form(self->dev)->type & DT_MASKS_GROUP)
    {
      GList *forms = dt_masks_get_visible_form(self->dev)->points;
      if(IS_NULL_PTR(forms)) goto end;
      
      dt_masks_form_group_t *grpt = (dt_masks_form_group_t *)forms->data;
      if(IS_NULL_PTR(grpt)) goto end;
      
      const dt_masks_form_t *form = dt_masks_get_from_id(self->dev, grpt->formid);
      if(!IS_NULL_PTR(form)) being_added = (form->type & shape_type);
    }
    else
      being_added = (dt_masks_get_visible_form(self->dev)->type & shape_type);
  }
 
  end:
  return being_added;
}
 
static gboolean rt_shape_buttons_can_start(GtkWidget *button, dt_iop_module_t *self,
                                           dt_masks_type_t type, gpointer user_data)
{
  //turn module on (else shape creation won't work)
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->gui->off), TRUE);
 
  //switch mask edit mode off
  dt_iop_gui_blend_data_t *bd = (dt_iop_gui_blend_data_t *)self->gui->blend_data;
  if(bd) bd->masks_shown = DT_MASKS_EDIT_OFF;
 
  const int allow = rt_allow_create_form(self);
  if(allow)
  {
    dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
    // we want to be sure that Retouch has focus
    dt_iop_request_focus(self);
    dt_iop_color_picker_reset(self, TRUE);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_edit_masks), FALSE);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_showmask), FALSE);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_suppress), FALSE);
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->colorpicker), FALSE);
  }
 
  return allow;
}
 
static dt_masks_type_t rt_shape_buttons_form_type(dt_iop_module_t *self, dt_masks_type_t type, gpointer user_data)
{
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  if(p->algorithm == DT_IOP_RETOUCH_CLONE || p->algorithm == DT_IOP_RETOUCH_HEAL)
    return type | DT_MASKS_CLONE;
 
  return type | DT_MASKS_NON_CLONE;
}
 
//---------------------------------------------------------------------------------
// GUI callbacks
//---------------------------------------------------------------------------------
 
static void rt_colorpick_color_set_callback(GtkColorButton *widget, dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return;
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  // turn off the other color picker
  dt_iop_color_picker_reset(self, TRUE);
 
  GdkRGBA c
      = (GdkRGBA){.red = p->fill_color[0], .green = p->fill_color[1], .blue = p->fill_color[2], .alpha = 1.0 };
  gtk_color_chooser_get_rgba(GTK_COLOR_CHOOSER(widget), &c);
  p->fill_color[0] = c.red;
  p->fill_color[1] = c.green;
  p->fill_color[2] = c.blue;
 
  const int index = rt_get_selected_shape_index(self->dev, p);
  if(index >= 0)
  {
    if(p->rt_forms[index].algorithm == DT_IOP_RETOUCH_FILL)
    {
      p->rt_forms[index].fill_color[0] = p->fill_color[0];
      p->rt_forms[index].fill_color[1] = p->fill_color[1];
      p->rt_forms[index].fill_color[2] = p->fill_color[2];
    }
  }
 
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
 
// wavelet decompose bar
#define RT_WDBAR_INSET 0.2f
#define lw DT_PIXEL_APPLY_DPI(1.0f)
 
static void rt_update_wd_bar_labels(dt_iop_retouch_params_t *p, dt_iop_retouch_gui_data_t *g)
{
  char text[256];
 
  snprintf(text, sizeof(text), "%i", p->curr_scale);
  gtk_label_set_text(g->lbl_curr_scale, text);
 
  snprintf(text, sizeof(text), "%i", p->num_scales);
  gtk_label_set_text(g->lbl_num_scales, text);
 
  snprintf(text, sizeof(text), "%i", p->merge_from_scale);
  gtk_label_set_text(g->lbl_merge_from_scale, text);
}
 
static void rt_num_scales_update(const int _num_scales, dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return;
 
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  const int num_scales = CLAMP(_num_scales, 0, RETOUCH_MAX_SCALES);
  if(p->num_scales == num_scales) return;
 
  p->num_scales = num_scales;
 
  if(p->num_scales < p->merge_from_scale) p->merge_from_scale = p->num_scales;
 
  rt_update_wd_bar_labels(p, g);
 
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
 
static void rt_curr_scale_update(const int _curr_scale, dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return;
 
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  const int curr_scale = CLAMP(_curr_scale, 0, RETOUCH_MAX_SCALES + 1);
  if(p->curr_scale == curr_scale) return;
 
  p->curr_scale = curr_scale;
 
  rt_show_forms_for_current_scale(self);
 
  // compute auto levels only the first time display wavelet scale is used,
  // only if levels values are the default
  // and a detail scale is displayed
  dt_iop_gui_enter_critical_section(self);
  if(g->displayed_wavelet_scale == 0 && p->preview_levels[0] == RETOUCH_PREVIEW_LVL_MIN
     && p->preview_levels[1] == 0.f && p->preview_levels[2] == RETOUCH_PREVIEW_LVL_MAX
     && g->preview_auto_levels == 0 && p->curr_scale > 0 && p->curr_scale <= p->num_scales)
  {
    g->preview_auto_levels = 1;
    g->displayed_wavelet_scale = 1;
  }
  dt_iop_gui_leave_critical_section(self);
 
  rt_update_wd_bar_labels(p, g);
 
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
 
static void rt_merge_from_scale_update(const int _merge_from_scale, dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return;
 
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  const int merge_from_scale = CLAMP(_merge_from_scale, 0, p->num_scales);
  if(p->merge_from_scale == merge_from_scale) return;
 
  p->merge_from_scale = merge_from_scale;
 
  rt_update_wd_bar_labels(p, g);
 
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
 
static gboolean rt_wdbar_leave_notify(GtkWidget *widget, GdkEventCrossing *event, dt_iop_module_t *self)
{
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  g->wdbar_mouse_x = g->wdbar_mouse_y = -1;
  g->curr_scale = -1;
  g->lower_cursor = g->upper_cursor = FALSE;
  g->lower_margin = g->upper_margin = FALSE;
 
  gtk_widget_queue_draw(g->wd_bar);
  return TRUE;
}
 
static gboolean rt_wdbar_button_press(GtkWidget *widget, GdkEventButton *event, dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return TRUE;
 
  dt_iop_request_focus(self);
 
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
  GtkAllocation allocation;
  gtk_widget_get_allocation(widget, &allocation);
  const int inset = round(RT_WDBAR_INSET * allocation.height);
  const float box_w = (allocation.width - 2.0f * inset) / (float)RETOUCH_NO_SCALES;
 
  if(event->button == 1)
  {
    if(g->lower_margin) // bottom slider
    {
      if(g->lower_cursor) // is over the arrow?
        g->is_dragging = DT_IOP_RETOUCH_WDBAR_DRAG_BOTTOM;
      else
        rt_num_scales_update(g->wdbar_mouse_x / box_w, self);
    }
    else if(g->upper_margin) // top slider
    {
      if(g->upper_cursor) // is over the arrow?
        g->is_dragging = DT_IOP_RETOUCH_WDBAR_DRAG_TOP;
      else
        rt_merge_from_scale_update(g->wdbar_mouse_x / box_w, self);
    }
    else if (g->curr_scale >= 0)
      rt_curr_scale_update(g->curr_scale, self);
  }
 
  gtk_widget_queue_draw(g->wd_bar);
  return TRUE;
}
 
static gboolean rt_wdbar_button_release(GtkWidget *widget, GdkEventButton *event, dt_iop_module_t *self)
{
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  if(event->button == 1) g->is_dragging = 0;
 
  gtk_widget_queue_draw(g->wd_bar);
  return TRUE;
}
 
static gboolean rt_wdbar_scrolled(GtkWidget *widget, GdkEventScroll *event, dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return TRUE;
 
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  dt_iop_request_focus(self);
 
  int delta_y;
  if(dt_gui_get_scroll_unit_deltas(event, NULL, &delta_y))
  {
    if(g->lower_margin) // bottom slider
      rt_num_scales_update(p->num_scales - delta_y, self);
    else if(g->upper_margin) // top slider
      rt_merge_from_scale_update(p->merge_from_scale - delta_y, self);
    else if (g->curr_scale >= 0)
      rt_curr_scale_update(p->curr_scale - delta_y, self);
  }
 
  gtk_widget_queue_draw(g->wd_bar);
  return TRUE;
}
 
static gboolean rt_wdbar_motion_notify(GtkWidget *widget, GdkEventMotion *event, dt_iop_module_t *self)
{
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
 
  GtkAllocation allocation;
  gtk_widget_get_allocation(widget, &allocation);
  const int inset = round(RT_WDBAR_INSET * allocation.height);
  const float box_w = (allocation.width - 2.0f * inset) / (float)RETOUCH_NO_SCALES;
  const float sh = 3.0f * lw + inset;
 
 
  /* record mouse position within control */
  g->wdbar_mouse_x = CLAMP(event->x - inset, 0, allocation.width - 2.0f * inset - 1.0f);
  g->wdbar_mouse_y = event->y;
 
  g->curr_scale = g->wdbar_mouse_x / box_w;
  g->lower_cursor = g->upper_cursor = FALSE;
  g->lower_margin = g->upper_margin = FALSE;
  if(g->wdbar_mouse_y <= sh)
  {
    g->upper_margin = TRUE;
    float middle = box_w * (0.5f + (float)p->merge_from_scale);
    g->upper_cursor = (g->wdbar_mouse_x >= (middle - inset)) && (g->wdbar_mouse_x <= (middle + inset));
    if (!(g->is_dragging)) g->curr_scale = -1;
  }
  else if (g->wdbar_mouse_y >= allocation.height - sh)
  {
    g->lower_margin = TRUE;
    float middle = box_w * (0.5f + (float)p->num_scales);
    g->lower_cursor = (g->wdbar_mouse_x >= (middle - inset)) && (g->wdbar_mouse_x <= (middle + inset));
    if (!(g->is_dragging)) g->curr_scale = -1;
  }
 
  if(g->is_dragging == DT_IOP_RETOUCH_WDBAR_DRAG_BOTTOM)
    rt_num_scales_update(g->curr_scale, self);
 
  if(g->is_dragging == DT_IOP_RETOUCH_WDBAR_DRAG_TOP)
    rt_merge_from_scale_update(g->curr_scale, self);
 
  gtk_widget_queue_draw(g->wd_bar);
  return TRUE;
}
 
static int rt_scale_has_shapes(dt_iop_retouch_params_t *p, const int scale)
{
  int has_shapes = 0;
 
  for(int i = 0; i < RETOUCH_NO_FORMS && has_shapes == 0; i++)
    has_shapes = (p->rt_forms[i].formid != 0 && p->rt_forms[i].scale == scale);
 
  return has_shapes;
}
 
static gboolean rt_wdbar_draw(GtkWidget *widget, cairo_t *crf, dt_iop_module_t *self)
{
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
 
 
  GdkRGBA border      = {0.066, 0.066, 0.066, 1};
  GdkRGBA original    = {.1, .1, .1, 1};
  GdkRGBA inactive    = {.15, .15, .15, 1};
  GdkRGBA active      = {.35, .35, .35, 1};
  GdkRGBA merge_from  = {.5, .5, .5, 1};
  GdkRGBA residual    = {.8, .8, .8, 1};
  GdkRGBA shapes      = {.75, .5, .0, 1};
  GdkRGBA color;
 
  float middle;
  const int first_scale_visible = (g->first_scale_visible > 0) ? g->first_scale_visible : RETOUCH_MAX_SCALES;
 
  GtkAllocation allocation;
  gtk_widget_get_allocation(widget, &allocation);
 
  cairo_surface_t *cst = dt_cairo_image_surface_create(CAIRO_FORMAT_ARGB32, allocation.width, allocation.height);
  cairo_t *cr = cairo_create(cst);
 
  // clear background
  gdk_cairo_set_source_rgba(cr, &inactive);
  cairo_paint(cr);
  cairo_save(cr);
 
  // geometry
  const int inset = round(RT_WDBAR_INSET * allocation.height);
  const int mk = 2 * inset;
  const float sh = 3.0f * lw + inset;
  const float box_w = (allocation.width - 2.0f * inset) / (float)RETOUCH_NO_SCALES;
  const float box_h = allocation.height - 2.0f * sh;
 
  // render the boxes
  cairo_set_antialias(cr, CAIRO_ANTIALIAS_NONE);
  for(int i = 0; i < RETOUCH_NO_SCALES; i++)
  {
    // draw box background
    if(i == 0)
      color = original;
    else if(i == p->num_scales + 1)
      color = residual;
    else if(i >= p->merge_from_scale && i <= p->num_scales && p->merge_from_scale > 0)
      color = merge_from;
    else if(i <= p->num_scales)
      color = active;
    else
      color = inactive;
 
    gdk_cairo_set_source_rgba(cr, &color);
    cairo_rectangle(cr, box_w * i + inset, sh, box_w, box_h);
    cairo_fill(cr);
 
    // if detail scale is visible at current zoom level inform it
    if(i >= first_scale_visible && i <= p->num_scales)
    {
      gdk_cairo_set_source_rgba(cr, &merge_from);
      cairo_rectangle(cr, box_w * i + inset, lw, box_w, 2.0f * lw);
      cairo_fill(cr);
    }
 
    // if the scale has shapes inform it
    if(rt_scale_has_shapes(p, i))
    {
      cairo_set_line_width(cr, lw);
      gdk_cairo_set_source_rgba(cr, &shapes);
      cairo_rectangle(cr, box_w * i + inset + lw / 2.0f, allocation.height - sh, box_w - lw, 2.0f * lw);
      cairo_fill(cr);
    }
 
    // draw the border
    cairo_set_line_width(cr, lw);
    gdk_cairo_set_source_rgba(cr, &border);
    cairo_rectangle(cr, box_w * i + inset, sh, box_w, box_h);
    cairo_stroke(cr);
  }
 
  cairo_set_antialias(cr, CAIRO_ANTIALIAS_DEFAULT);
  cairo_restore(cr);
 
  // dot for the current scale
  if(p->curr_scale >= p->merge_from_scale && p->curr_scale <= p->num_scales && p->merge_from_scale > 0)
    color = active;
  else
    color = merge_from;
 
  if(p->curr_scale >= 0 && p->curr_scale < RETOUCH_NO_SCALES)
  {
    cairo_set_line_width(cr, lw);
    gdk_cairo_set_source_rgba(cr, &color);
    middle = box_w * (0.5f + (float)p->curr_scale);
    cairo_arc(cr, middle + inset, 0.5f * box_h + sh, 0.5f * inset, 0, 2.0f * M_PI);
    cairo_fill(cr);
    cairo_stroke(cr);
  }
 
  // mouse hover on a scale
  if(g->curr_scale >= 0)
  {
    cairo_set_line_width(cr, lw);
    if(g->curr_scale == p->num_scales + 1) color = inactive;
    else color = residual;
    gdk_cairo_set_source_rgba(cr, &color);
    cairo_rectangle(cr, box_w * g->curr_scale + inset + lw, sh + lw, box_w - 2.0f * lw, box_h - 2.0f * lw);
    cairo_stroke(cr);
  }
 
  /* render control points handles */
 
  // draw number of scales arrow (bottom arrow)
  middle = box_w * (0.5f + (float)p->num_scales);
  if(g->lower_cursor || g->is_dragging == DT_IOP_RETOUCH_WDBAR_DRAG_BOTTOM)
  {
    cairo_set_source_rgb(cr, 0.67, 0.67, 0.67);
    dtgtk_cairo_paint_solid_triangle(cr, middle, box_h + 5.0f * lw, mk, mk, CPF_DIRECTION_UP, NULL);
  }
  else
  {
    cairo_set_source_rgb(cr, 0.54, 0.54, 0.54);
    dtgtk_cairo_paint_triangle(cr, middle, box_h + 5.0f * lw, mk, mk, CPF_DIRECTION_UP, NULL);
  }
 
  // draw merge scales arrow (top arrow)
  middle = box_w * (0.5f + (float)p->merge_from_scale);
  if(g->upper_cursor || g->is_dragging == DT_IOP_RETOUCH_WDBAR_DRAG_TOP)
  {
    cairo_set_source_rgb(cr, 0.67, 0.67, 0.67);
    dtgtk_cairo_paint_solid_triangle(cr, middle, 3.0f * lw, mk, mk, CPF_DIRECTION_DOWN, NULL);
  }
  else
  {
    cairo_set_source_rgb(cr, 0.54, 0.54, 0.54);
    dtgtk_cairo_paint_triangle(cr, middle, 3.0f * lw, mk, mk, CPF_DIRECTION_DOWN, NULL);
  }
 
  /* push mem surface into widget */
  cairo_destroy(cr);
  cairo_set_source_surface(crf, cst, 0, 0);
  cairo_paint(crf);
  cairo_surface_destroy(cst);
 
  return TRUE;
}
 
static float rt_gslider_scale_callback(GtkWidget *self, float inval, int dir)
{
  float outval;
  switch(dir)
  {
    case GRADIENT_SLIDER_SET:
      outval = (inval - RETOUCH_PREVIEW_LVL_MIN) / (RETOUCH_PREVIEW_LVL_MAX - RETOUCH_PREVIEW_LVL_MIN);
      break;
    case GRADIENT_SLIDER_GET:
      outval = (RETOUCH_PREVIEW_LVL_MAX - RETOUCH_PREVIEW_LVL_MIN) * inval + RETOUCH_PREVIEW_LVL_MIN;
      break;
    default:
      outval = inval;
  }
  return outval;
}
 
 
static void rt_gslider_changed(GtkDarktableGradientSlider *gslider, dt_iop_module_t *self)
{
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
 
  double dlevels[3];
 
  if(dt_gui_widgets_suppressed()) return;
 
  dtgtk_gradient_slider_multivalue_get_values(gslider, dlevels);
 
  for (int i = 0; i < 3; i++) p->preview_levels[i] = dlevels[i];
 
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
 
}
 
 
void color_picker_apply(dt_iop_module_t *self, GtkWidget *picker, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
 
  if(fabsf(p->fill_color[0] - self->picked_output_color[0]) < 0.0001f
     && fabsf(p->fill_color[1] - self->picked_output_color[1]) < 0.0001f
     && fabsf(p->fill_color[2] - self->picked_output_color[2]) < 0.0001f)
  {
    // interrupt infinite loops
    return;
  }
 
  p->fill_color[0] = self->picked_output_color[0];
  p->fill_color[1] = self->picked_output_color[1];
  p->fill_color[2] = self->picked_output_color[2];
 
  const int index = rt_get_selected_shape_index(self->dev, p);
  if(index >= 0)
  {
    if(p->rt_forms[index].algorithm == DT_IOP_RETOUCH_FILL)
    {
      p->rt_forms[index].fill_color[0] = p->fill_color[0];
      p->rt_forms[index].fill_color[1] = p->fill_color[1];
      p->rt_forms[index].fill_color[2] = p->fill_color[2];
    }
  }
 
  rt_display_selected_fill_color(g, p);
 
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
 
static gboolean rt_copypaste_scale_callback(GtkToggleButton *togglebutton, GdkEventButton *event, dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return TRUE;
 
  dt_gui_freeze_begin();
 
  int scale_copied = 0;
  const int active = !gtk_toggle_button_get_active(togglebutton);
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  if(togglebutton == (GtkToggleButton *)g->bt_copy_scale)
  {
    g->copied_scale = (active) ? p->curr_scale : -1;
  }
  else if(togglebutton == (GtkToggleButton *)g->bt_paste_scale)
  {
    rt_paste_forms_from_scale(p, g->copied_scale, p->curr_scale);
    rt_show_forms_for_current_scale(self);
 
    scale_copied = 1;
    g->copied_scale = -1;
  }
 
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_copy_scale), g->copied_scale >= 0);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_paste_scale), g->copied_scale >= 0);
  gtk_widget_set_sensitive(g->bt_paste_scale, g->copied_scale >= 0);
 
  dt_gui_freeze_end();
 
  if(scale_copied) dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
 
  return TRUE;
}
 
// Whether some OTHER source (the generic blend-mask display) currently occupies
// request_mask_display, as opposed to one of retouch's own preview toggles below.
static gboolean rt_blend_mask_conflicts(dt_iop_module_t *module, dt_iop_retouch_gui_data_t *g)
{
  return module->request_mask_display && !g->mask_display && !g->display_wavelet_scale;
}
 
// Whether any of retouch's own preview toggles needs the pipeline cache bypassed for this
// module. Combines all three (not just the caller's own flag), or clearing one would drop a
// bypass another still needs -- bypass_cache is a single shared field, unlike
// request_mask_display below, so no cross-module ownership concern applies here.
static gboolean rt_any_preview_active(dt_iop_retouch_gui_data_t *g)
{
  return g->mask_display || g->display_wavelet_scale || g->suppress_mask;
}
 
// Syncs bypass_cache (whether the pipe needs to bypass at all) and bypass_cache_variant (which
// combination of the three preview toggles is active) together. bypass_cache alone cannot
// distinguish e.g. "wavelet scale only" from "wavelet scale + suppress": both keep it TRUE, so
// toggling suppress on top of an already-active wavelet-scale preview would not change the
// pipeline hash and the display would keep showing the pre-toggle (still-retouched) frame even
// though process_internal()/process_cl() had already recomputed the correct, retouch-free one.
// bypass_cache_variant closes that gap -- see dt_iop_module_t.bypass_cache_variant.
static void rt_sync_bypass_cache(dt_iop_module_t *module, dt_iop_retouch_gui_data_t *g)
{
  const int variant = (g->mask_display ? 1 : 0) | (g->display_wavelet_scale ? 2 : 0) | (g->suppress_mask ? 4 : 0);
  dt_iop_set_cache_bypass_variant(module, variant);
  dt_iop_set_cache_bypass(module, rt_any_preview_active(g));
}
 
// Mirrors mask_display/display_wavelet_scale into the pipeline cache key
// (request_mask_display) -- otherwise toggling either back off keeps serving whatever was last
// cached instead of the real image, since these GUI-only flags are invisible to the pipeline
// hash on their own. Keep them on separate bits (mirroring the MASK-vs-PASSTHRU split
// process_internal already applies to pipe->mask_display) rather than collapsing to one value,
// or "show mask" and "show wavelet scale" would hash identically whenever curr_scale/params
// haven't changed and one preview mode would reuse the other's cached buffer.
//
// Only call this once rt_blend_mask_conflicts() has already been checked and passed: unlike
// bypass_cache, request_mask_display can belong to the generic blend-mask display instead of to
// retouch, and must not be blindly overwritten. rt_suppress_callback has no such guard, so it
// only calls rt_sync_bypass_cache() (bypass_cache/bypass_cache_variant), never this.
static void rt_sync_mask_display_request(dt_iop_module_t *module, dt_iop_retouch_gui_data_t *g)
{
  dt_dev_pixelpipe_display_mask_t display_request = DT_DEV_PIXELPIPE_DISPLAY_NONE;
  if(g->mask_display) display_request |= DT_DEV_PIXELPIPE_DISPLAY_MASK;
  if(g->display_wavelet_scale) display_request |= DT_DEV_PIXELPIPE_DISPLAY_PASSTHRU;
  module->request_mask_display = display_request;
}
 
static gboolean rt_display_wavelet_scale_callback(GtkToggleButton *togglebutton, GdkEventButton *event, dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return TRUE;
 
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  // if blend module is displaying mask do not display wavelet scales
  if(rt_blend_mask_conflicts(self, g))
  {
    dt_control_log(_("cannot display scales when the blending mask is displayed"));
 
    dt_gui_freeze_begin();
    gtk_toggle_button_set_active(togglebutton, FALSE);
    dt_gui_freeze_end();
    return TRUE;
  }
 
  if(self->gui->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->gui->off), 1);
  dt_iop_request_focus(self);
 
  g->display_wavelet_scale = !gtk_toggle_button_get_active(togglebutton);
  rt_sync_mask_display_request(self, g);
  rt_sync_bypass_cache(self, g);
 
  rt_show_hide_controls(self);
 
  // compute auto levels only the first time display wavelet scale is used,
  // only if levels values are the default
  // and a detail scale is displayed
  dt_iop_gui_enter_critical_section(self);
  if(g->displayed_wavelet_scale == 0 && p->preview_levels[0] == RETOUCH_PREVIEW_LVL_MIN
     && p->preview_levels[1] == 0.f && p->preview_levels[2] == RETOUCH_PREVIEW_LVL_MAX
     && g->preview_auto_levels == 0 && p->curr_scale > 0 && p->curr_scale <= p->num_scales)
  {
    g->preview_auto_levels = 1;
    g->displayed_wavelet_scale = 1;
  }
  dt_iop_gui_leave_critical_section(self);
 
  dt_dev_pixelpipe_update_history_main(self->dev);
 
  gtk_toggle_button_set_active(togglebutton, g->display_wavelet_scale);
  return TRUE;
}
 
static void rt_develop_ui_pipe_finished_callback(gpointer instance, gpointer user_data)
{
  dt_iop_module_t *self = (dt_iop_module_t *)user_data;
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  // FIXME: this doesn't seems the right place to update params and GUI ...
  // update auto levels
  dt_iop_gui_enter_critical_section(self);
  if(g->preview_auto_levels == 2)
  {
    g->preview_auto_levels = -1;
 
    dt_iop_gui_leave_critical_section(self);
 
    for(int i = 0; i < 3; i++) p->preview_levels[i] = g->preview_levels[i];
 
    dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
 
    dt_iop_gui_enter_critical_section(self);
 
    // update the gradient slider
    double dlevels[3];
    for(int i = 0; i < 3; i++) dlevels[i] = p->preview_levels[i];
 
    dt_gui_freeze_begin();
    dtgtk_gradient_slider_multivalue_set_values(g->preview_levels_gslider, dlevels);
    dt_gui_freeze_end();
 
    g->preview_auto_levels = 0;
  }
  dt_iop_gui_leave_critical_section(self);
 
  // just in case zoom level has changed
  gtk_widget_queue_draw(GTK_WIDGET(g->wd_bar));
}
 
static gboolean rt_auto_levels_callback(GtkToggleButton *togglebutton, GdkEventButton *event, dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return FALSE;
 
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  if(self->gui->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->gui->off), 1);
  dt_iop_request_focus(self);
 
  dt_iop_gui_enter_critical_section(self);
  if(g->preview_auto_levels == 0)
  {
    g->preview_auto_levels = 1;
  }
  dt_iop_gui_leave_critical_section(self);
 
  dt_dev_pixelpipe_update_history_main(self->dev);
 
  return TRUE;
}
 
static void rt_mask_opacity_callback(GtkWidget *slider, dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return;
 
  const int shape_id = rt_get_selected_shape_id(self);
 
  if(shape_id > 0)
  {
    const float opacity = dt_bauhaus_slider_get(slider);
    rt_masks_form_change_opacity(self, shape_id, opacity);
  }
 
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
 
void gui_post_expose (struct dt_iop_module_t *self,
                      cairo_t *cr,
                      int32_t width,
                      int32_t height,
                      int32_t pointerx,
                      int32_t pointery)
{
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
  if(IS_NULL_PTR(g)) return;
 
  const int shape_id = rt_get_selected_shape_id(self);
 
  if(shape_id > 0)
  {
    dt_gui_freeze_begin();
    dt_bauhaus_slider_set(g->sl_mask_opacity, rt_masks_form_get_opacity(self, shape_id));
    dt_gui_freeze_end();
  }
}
 
static gboolean rt_edit_masks_callback(GtkWidget *widget, GdkEventButton *event, dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return FALSE;
 
  // if we don't have the focus, request for it and quit, gui_focus() do the rest
  if(self->dev->gui_module != self)
  {
    dt_iop_request_focus(self);
    return FALSE;
  }
 
  dt_iop_gui_blend_data_t *bd = (dt_iop_gui_blend_data_t *)self->gui->blend_data;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  //hide all shapes and free if some are in creation
  if(self->dev->form_gui->creation && self->dev->form_gui->creation_module == self)
    dt_masks_change_form_gui(self->dev, NULL);
 
  dt_masks_shape_buttons_deactivate_all(NULL);
 
  if(event->button == 1)
  {
    dt_gui_freeze_begin();
 
    dt_iop_color_picker_reset(self, TRUE);
 
    dt_masks_form_t *grp = dt_masks_get_from_id(self->dev, self->blend_params->mask_id);
    if(!IS_NULL_PTR(grp) && (grp->type & DT_MASKS_GROUP) && grp->points)
    {
      const gboolean control_button_pressed = dt_modifier_is(event->state, DT_PRIMARY_MASK);
 
      switch(bd->masks_shown)
      {
        case DT_MASKS_EDIT_FULL:
          bd->masks_shown = control_button_pressed ? DT_MASKS_EDIT_RESTRICTED : DT_MASKS_EDIT_OFF;
          break;
 
        case DT_MASKS_EDIT_RESTRICTED:
          bd->masks_shown = !control_button_pressed ? DT_MASKS_EDIT_FULL : DT_MASKS_EDIT_OFF;
          break;
 
        default:
        case DT_MASKS_EDIT_OFF:
          bd->masks_shown = control_button_pressed ? DT_MASKS_EDIT_RESTRICTED : DT_MASKS_EDIT_FULL;
          break;
      }
    }
    else
      bd->masks_shown = DT_MASKS_EDIT_OFF;
 
    rt_show_forms_for_current_scale(self);
 
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_edit_masks),
                                 (bd->masks_shown != DT_MASKS_EDIT_OFF) && (self->dev->gui_module == self));
 
    dt_gui_freeze_end();
 
    return TRUE;
  }
 
  return TRUE;
}
 
static gboolean rt_algo_pair_compatible(const dt_iop_retouch_algo_type_t from,
                                        const dt_iop_retouch_algo_type_t to)
{
  return ((from == DT_IOP_RETOUCH_CLONE && to == DT_IOP_RETOUCH_HEAL)
          || (from == DT_IOP_RETOUCH_HEAL && to == DT_IOP_RETOUCH_CLONE)
          || (from == DT_IOP_RETOUCH_BLUR && to == DT_IOP_RETOUCH_FILL)
          || (from == DT_IOP_RETOUCH_FILL && to == DT_IOP_RETOUCH_BLUR));
}
 
static gboolean rt_select_algorithm_callback(GtkToggleButton *togglebutton, GdkEventButton *e,
                                             dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return FALSE;
 
  dt_gui_freeze_begin();
 
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  dt_iop_retouch_algo_type_t new_algo = DT_IOP_RETOUCH_HEAL;
 
  if(togglebutton == (GtkToggleButton *)g->bt_blur)
    new_algo = DT_IOP_RETOUCH_BLUR;
  else if(togglebutton == (GtkToggleButton *)g->bt_clone)
    new_algo = DT_IOP_RETOUCH_CLONE;
  else if(togglebutton == (GtkToggleButton *)g->bt_heal)
    new_algo = DT_IOP_RETOUCH_HEAL;
  else if(togglebutton == (GtkToggleButton *)g->bt_fill)
    new_algo = DT_IOP_RETOUCH_FILL;
 
  // check if we have to do something
  gboolean accept = TRUE;
 
  const int index = rt_get_selected_shape_index(self->dev, p);
  if(index >= 0 && dt_modifier_is(e->state, DT_PRIMARY_MASK))
  {
    const dt_iop_retouch_algo_type_t current_algo = p->rt_forms[index].algorithm;
    accept = (new_algo != current_algo && !rt_algo_pair_compatible(current_algo, new_algo));
  }
 
  if(accept) p->algorithm = new_algo;
 
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_clone), (p->algorithm == DT_IOP_RETOUCH_CLONE));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_heal), (p->algorithm == DT_IOP_RETOUCH_HEAL));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_blur), (p->algorithm == DT_IOP_RETOUCH_BLUR));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_fill), (p->algorithm == DT_IOP_RETOUCH_FILL));
 
  rt_show_hide_controls(self);
 
  if(!accept)
  {
    dt_gui_freeze_end();
    return FALSE;
  }
 
  if(index >= 0 && dt_modifier_is(e->state, DT_PRIMARY_MASK))
  {
    if(p->algorithm != p->rt_forms[index].algorithm)
    {
      p->rt_forms[index].algorithm = p->algorithm;
      dt_control_queue_redraw_center();
    }
  }
  else if(self->dev->form_gui->creation && (self->dev->form_gui->creation_module == self))
  {
    dt_iop_request_focus(self);
 
    dt_masks_type_t type = DT_MASKS_CIRCLE;
    if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->bt_polygon)))
      type = DT_MASKS_POLYGON;
    else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->bt_circle)))
      type = DT_MASKS_CIRCLE;
    else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->bt_ellipse)))
      type = DT_MASKS_ELLIPSE;
    else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->bt_brush)))
      type = DT_MASKS_BRUSH;
 
    dt_masks_type_t masks_type = DT_MASKS_NONE;
    if(p->algorithm == DT_IOP_RETOUCH_CLONE || p->algorithm == DT_IOP_RETOUCH_HEAL)
      masks_type = (type | DT_MASKS_CLONE);
    else
      masks_type = (type | DT_MASKS_NON_CLONE);
 
    dt_masks_creation_mode_enter(self->dev, self, masks_type);
 
    dt_control_queue_redraw_center();
  }
 
  dt_gui_freeze_end();
 
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
 
  // if we have the shift key pressed, we set it as default
  if(dt_modifier_is(e->state, GDK_SHIFT_MASK))
  {
    dt_conf_set_int("plugins/darkroom/retouch/default_algo", p->algorithm);
    // and we show a toat msg to confirm
    if(p->algorithm == DT_IOP_RETOUCH_CLONE)
      dt_control_log(N_("default tool changed to %s"), N_("cloning"));
    else if(p->algorithm == DT_IOP_RETOUCH_HEAL)
      dt_control_log(N_("default tool changed to %s"), N_("healing"));
    else if(p->algorithm == DT_IOP_RETOUCH_FILL)
      dt_control_log(N_("default tool changed to %s"), N_("blur"));
    else if(p->algorithm == DT_IOP_RETOUCH_BLUR)
      dt_control_log(N_("default tool changed to %s"), N_("fill"));
  }
 
  return TRUE;
}
 
static gboolean rt_showmask_callback(GtkToggleButton *togglebutton, GdkEventButton *event, dt_iop_module_t *module)
{
  if(dt_gui_widgets_suppressed()) return TRUE;
 
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(module);
 
  // if blend module is displaying mask do not display it here
  if(rt_blend_mask_conflicts(module, g))
  {
    dt_control_log(_("cannot display masks when the blending mask is displayed"));
 
    gtk_toggle_button_set_active(togglebutton, FALSE);
    return TRUE;
  }
 
  g->mask_display = !gtk_toggle_button_get_active(togglebutton);
  rt_sync_mask_display_request(module, g);
  rt_sync_bypass_cache(module, g);
 
  if(module->gui->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(module->gui->off), 1);
  dt_iop_request_focus(module);
 
  dt_dev_pixelpipe_update_history_main(module->dev);
 
  gtk_toggle_button_set_active(togglebutton, g->mask_display);
  return TRUE;
}
 
static gboolean rt_suppress_callback(GtkToggleButton *togglebutton, GdkEventButton *event, dt_iop_module_t *module)
{
  if(dt_gui_widgets_suppressed()) return TRUE;
 
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(module);
  g->suppress_mask = !gtk_toggle_button_get_active(togglebutton);
  // No rt_blend_mask_conflicts() guard on this button, so only bypass_cache/bypass_cache_variant
  // are synced here -- request_mask_display may currently belong to the blend-mask display, not
  // to retouch.
  rt_sync_bypass_cache(module, g);
 
  if(module->gui->off) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(module->gui->off), 1);
  dt_iop_request_focus(module);
 
  dt_dev_pixelpipe_update_history_main(module->dev);
 
  gtk_toggle_button_set_active(togglebutton, g->suppress_mask);
  return TRUE;
}
 
void gui_changed(dt_iop_module_t *self, GtkWidget *w, void *previous)
{
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  if(w == g->cmb_fill_mode)
  {
    dt_gui_freeze_begin();
    rt_show_hide_controls(self);
    dt_gui_freeze_end();
  }
  else
  {
    const int index = rt_get_selected_shape_index(self->dev, p);
    if(index >= 0)
    {
      if(p->rt_forms[index].algorithm == DT_IOP_RETOUCH_BLUR)
      {
        p->rt_forms[index].blur_type = p->blur_type;
        p->rt_forms[index].blur_radius = p->blur_radius;
      }
      else if(p->rt_forms[index].algorithm == DT_IOP_RETOUCH_FILL)
      {
        p->rt_forms[index].fill_mode = p->fill_mode;
        p->rt_forms[index].fill_brightness = p->fill_brightness;
      }
    }
  }
}
 
//--------------------------------------------------------------------------------------------------
// GUI
//--------------------------------------------------------------------------------------------------
 
void masks_selection_changed(struct dt_iop_module_t *self, const int form_selected_id)
{
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
  if(IS_NULL_PTR(g)) return;
 
  dt_iop_gui_enter_critical_section(self);
  rt_load_shape_algo_in_gui(self, form_selected_id);
  dt_iop_gui_leave_critical_section(self);
}
 
void init(dt_iop_module_t *module)
{
  dt_iop_default_init(module);
 
  dt_iop_retouch_params_t *d = module->default_params;
 
  d->preview_levels[0] = RETOUCH_PREVIEW_LVL_MIN;
  d->preview_levels[1] = 0.f;
  d->preview_levels[2] = RETOUCH_PREVIEW_LVL_MAX;
  d->algorithm = dt_conf_get_int("plugins/darkroom/retouch/default_algo");
}
 
void init_global(dt_iop_module_so_t *module)
{
  const int program = 21; // retouch.cl, from programs.conf
  dt_iop_retouch_global_data_t *gd = (dt_iop_retouch_global_data_t *)malloc(sizeof(dt_iop_retouch_global_data_t));
  module->data = gd;
  gd->kernel_retouch_clear_alpha = dt_opencl_create_kernel(program, "retouch_clear_alpha");
  gd->kernel_retouch_copy_alpha = dt_opencl_create_kernel(program, "retouch_copy_alpha");
  gd->kernel_retouch_copy_buffer_to_buffer = dt_opencl_create_kernel(program, "retouch_copy_buffer_to_buffer");
  gd->kernel_retouch_copy_buffer_to_image = dt_opencl_create_kernel(program, "retouch_copy_buffer_to_image");
  gd->kernel_retouch_fill = dt_opencl_create_kernel(program, "retouch_fill");
  gd->kernel_retouch_copy_image_to_buffer_masked
      = dt_opencl_create_kernel(program, "retouch_copy_image_to_buffer_masked");
  gd->kernel_retouch_copy_buffer_to_buffer_masked
      = dt_opencl_create_kernel(program, "retouch_copy_buffer_to_buffer_masked");
  gd->kernel_retouch_image_rgb2lab = dt_opencl_create_kernel(program, "retouch_image_rgb2lab");
  gd->kernel_retouch_image_lab2rgb = dt_opencl_create_kernel(program, "retouch_image_lab2rgb");
  gd->kernel_retouch_copy_mask_to_alpha = dt_opencl_create_kernel(program, "retouch_copy_mask_to_alpha");
}
 
void cleanup_global(dt_iop_module_so_t *module)
{
  dt_iop_retouch_global_data_t *gd = (dt_iop_retouch_global_data_t *)module->data;
 
  dt_opencl_free_kernel(gd->kernel_retouch_clear_alpha);
  dt_opencl_free_kernel(gd->kernel_retouch_copy_alpha);
  dt_opencl_free_kernel(gd->kernel_retouch_copy_buffer_to_buffer);
  dt_opencl_free_kernel(gd->kernel_retouch_copy_buffer_to_image);
  dt_opencl_free_kernel(gd->kernel_retouch_fill);
  dt_opencl_free_kernel(gd->kernel_retouch_copy_image_to_buffer_masked);
  dt_opencl_free_kernel(gd->kernel_retouch_copy_buffer_to_buffer_masked);
  dt_opencl_free_kernel(gd->kernel_retouch_image_rgb2lab);
  dt_opencl_free_kernel(gd->kernel_retouch_image_lab2rgb);
  dt_opencl_free_kernel(gd->kernel_retouch_copy_mask_to_alpha);
 
  dt_free(module->data);
}
 
void gui_focus(struct dt_iop_module_t *self, gboolean in)
{
  if(self->enabled)
  {
    dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
    if(in)
    {
      dt_iop_gui_blend_data_t *bd = (dt_iop_gui_blend_data_t *)self->gui->blend_data;
      //only show shapes if shapes exist
      dt_masks_form_t *grp = dt_masks_get_from_id(self->dev, self->blend_params->mask_id);
      if(!IS_NULL_PTR(grp) && (grp->type & DT_MASKS_GROUP) && grp->points)
      {
        // got focus, show all shapes
        if(bd->masks_shown == DT_MASKS_EDIT_OFF)
          dt_masks_set_edit_mode(self, DT_MASKS_EDIT_FULL);
 
        rt_show_forms_for_current_scale(self);
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_edit_masks),
                                     (bd->masks_shown != DT_MASKS_EDIT_OFF)
                                         && (self->dev->gui_module == self));
      }
    }
    else
    {
      // lost focus, hide all shapes and free if some are in creation
      if(self->dev->form_gui->creation && self->dev->form_gui->creation_module == self)
        dt_masks_change_form_gui(self->dev, NULL);
 
      dt_masks_shape_buttons_deactivate_all(NULL);
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_edit_masks), FALSE);
 
      dt_masks_set_edit_mode(self, DT_MASKS_EDIT_OFF);
    }
 
    // if we are switching between display modes we have to reprocess the main image
    if(g->display_wavelet_scale || g->mask_display || g->suppress_mask)
      dt_dev_pixelpipe_update_history_main(self->dev);
  }
}
 
void commit_params(struct dt_iop_module_t *self, dt_iop_params_t *params, dt_dev_pixelpipe_t *pipe,
                   dt_dev_pixelpipe_iop_t *piece)
{
  dt_iop_retouch_params_t synced_params = *(dt_iop_retouch_params_t *)params;
  if(!IS_NULL_PTR(pipe) && !IS_NULL_PTR(pipe->forms))
  {
    rt_resynch_params(self, &synced_params, pipe->forms);
  }
  else
  {
    dt_pthread_rwlock_rdlock(&self->dev->masks_mutex);
    rt_resynch_params(self, &synced_params, self->dev->forms);
    dt_pthread_rwlock_unlock(&self->dev->masks_mutex);
  }
 
  memcpy(piece->data, &synced_params, sizeof(dt_iop_retouch_params_t));
}
 
void tiling_callback(struct dt_iop_module_t *self, const struct dt_dev_pixelpipe_t *pipe, const struct dt_dev_pixelpipe_iop_t *piece, struct dt_develop_tiling_t *tiling)
{
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  const float require = 2.0f;
  const float require_cl = 1.0f  // in_retouch
     + ((p->num_scales > 0) ? 4.0f : 2.0f); // dwt_wavelet_decompose_cl requires 4 buffers, otherwise 2.0f is enough
  // FIXME the above are worst case values, we might iterate through the dt_iop_retouch_form_data_t to get
  // the largest bounding box
 
  tiling->factor = 2.0f + require; // input & output buffers + internal requirements
  tiling->factor_cl = 2.0f + require_cl;
  tiling->maxbuf = 1.0f;
  tiling->maxbuf_cl = 1.0f;
  tiling->overhead = 0;
  tiling->overlap = 0;
  tiling->xalign = 1;
  tiling->yalign = 1;
}
 
void init_pipe(struct dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
  piece->data = dt_calloc_align(sizeof(dt_iop_retouch_data_t));
  piece->data_size = sizeof(dt_iop_retouch_data_t);
}
 
void cleanup_pipe(struct dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
  dt_free_align(piece->data);
  piece->data = NULL;
}
 
void gui_update(dt_iop_module_t *self)
{
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
 
  // check if there is new or deleted forms
  dt_pthread_rwlock_rdlock(&self->dev->masks_mutex);
  rt_resynch_params(self, p, self->dev->forms);
  dt_pthread_rwlock_unlock(&self->dev->masks_mutex);
 
  // update clones count
  const dt_masks_form_t *grp = dt_masks_get_from_id(self->dev, self->blend_params->mask_id);
  guint nb = 0;
  if(grp && (grp->type & DT_MASKS_GROUP)) nb = g_list_length(grp->points);
  gchar *str = g_strdup_printf("%d", nb);
  gtk_label_set_text(g->label_form, str);
  dt_free(str);
 
  // update wavelet decompose labels
  rt_update_wd_bar_labels(p, g);
 
  // update selected shape label
  rt_display_selected_shapes_lbl(self->dev, g);
 
  // show the shapes for the current scale
  rt_show_forms_for_current_scale(self);
 
  // enable/disable algorithm toolbar
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_clone), p->algorithm == DT_IOP_RETOUCH_CLONE);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_blur), p->algorithm == DT_IOP_RETOUCH_BLUR);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_heal), p->algorithm == DT_IOP_RETOUCH_HEAL);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_fill), p->algorithm == DT_IOP_RETOUCH_FILL);
 
  // enable/disable shapes toolbar
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_circle), rt_shape_is_being_added(self, DT_MASKS_CIRCLE));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_polygon), rt_shape_is_being_added(self, DT_MASKS_POLYGON));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_ellipse), rt_shape_is_being_added(self, DT_MASKS_ELLIPSE));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_brush), rt_shape_is_being_added(self, DT_MASKS_BRUSH));
 
  // update the rest of the fields
  gtk_widget_queue_draw(GTK_WIDGET(g->wd_bar));
 
  dt_bauhaus_combobox_set(g->cmb_blur_type, p->blur_type);
  dt_bauhaus_slider_set(g->sl_blur_radius, p->blur_radius);
  dt_bauhaus_slider_set(g->sl_fill_brightness, p->fill_brightness);
  dt_bauhaus_combobox_set(g->cmb_fill_mode, p->fill_mode);
  dt_bauhaus_combobox_set(g->cmb_heal_algorithm, p->heal_algorithm);
 
  rt_display_selected_fill_color(g, p);
 
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_display_wavelet_scale), g->display_wavelet_scale);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_copy_scale), g->copied_scale >= 0);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_paste_scale), g->copied_scale >= 0);
  gtk_widget_set_sensitive(g->bt_paste_scale, g->copied_scale >= 0);
 
  // show/hide some fields
  rt_show_hide_controls(self);
 
  // update edit shapes status
  dt_iop_gui_blend_data_t *bd = (dt_iop_gui_blend_data_t *)self->gui->blend_data;
 
  //only toggle shape show button if shapes exist
  if(!IS_NULL_PTR(grp) && (grp->type & DT_MASKS_GROUP) && grp->points)
  {
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_edit_masks),
                                 (bd->masks_shown != DT_MASKS_EDIT_OFF) && (self->dev->gui_module == self));
  }
  else
  {
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_edit_masks), FALSE);
  }
 
  // update the gradient slider
  double dlevels[3];
  for(int i = 0; i < 3; i++) dlevels[i] = p->preview_levels[i];
  dtgtk_gradient_slider_multivalue_set_values(g->preview_levels_gslider, dlevels);
}
 
void change_image(struct dt_iop_module_t *self)
{
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
  if(!IS_NULL_PTR(g))
  {
    g->copied_scale = -1;
    g->mask_display = 0;
    g->suppress_mask = 0;
    g->display_wavelet_scale = 0;
    g->displayed_wavelet_scale = 0;
    g->first_scale_visible = RETOUCH_MAX_SCALES + 1;
 
    g->preview_auto_levels = 0;
    g->preview_levels[0] = RETOUCH_PREVIEW_LVL_MIN;
    g->preview_levels[1] = 0.f;
    g->preview_levels[2] = RETOUCH_PREVIEW_LVL_MAX;
 
    g->is_dragging = 0;
    g->wdbar_mouse_x = g->wdbar_mouse_y = -1;
    g->curr_scale = -1;
    g->lower_cursor = g->upper_cursor = FALSE;
    g->lower_margin = g->upper_margin = FALSE;
  }
}
 
void gui_init(dt_iop_module_t *self)
{
  dt_iop_retouch_gui_data_t *g = IOP_GUI_ALLOC(retouch);
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->default_params;
 
  change_image(self);
 
  // shapes toolbar
  GtkWidget *hbox_shapes = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
 
  gtk_box_pack_start(GTK_BOX(hbox_shapes), dt_ui_label_new(_("shapes:")), FALSE, TRUE, 0);
  g->label_form = GTK_LABEL(gtk_label_new("-1"));
  gtk_box_pack_start(GTK_BOX(hbox_shapes), GTK_WIDGET(g->label_form), FALSE, TRUE, DT_PIXEL_APPLY_DPI(5));
  gtk_widget_set_tooltip_text(hbox_shapes,
               _("To add a shape select an algorithm and a shape type and click on the image.\n"
                 "Shapes are added to the current scale"));
 
  g->bt_edit_masks = dt_iop_togglebutton_new(self, N_("editing"), N_("Show and edit shapes on the current scale"),
                                                                  N_("show and edit shapes in restricted mode"),
                                             G_CALLBACK(rt_edit_masks_callback), TRUE, 0, 0,
                                             dtgtk_cairo_paint_masks_edit, hbox_shapes);
 
  GtkWidget *shape_buttons[DEVELOP_MASKS_NB_SHAPES] = { 0 };
  const dt_masks_shape_buttons_config_t shape_buttons_config = {
    .dev = self->dev,
    .owner_module = self,
    .creation_module = self,
    .buttons = shape_buttons,
    .types = NULL,
    .action_section = N_("shapes"),
    .flags = DT_MASKS_SHAPE_BUTTONS_ALL & ~DT_MASKS_SHAPE_BUTTONS_GRADIENT, // All shapes minus gradient
    .register_flags = DT_MASKS_SHAPE_BUTTONS_ALL & ~DT_MASKS_SHAPE_BUTTONS_GRADIENT,
    .local = TRUE,
    .user_data = NULL,
    .can_start = rt_shape_buttons_can_start,
    .form_type = rt_shape_buttons_form_type,
    .started = NULL,
    .exited = NULL,
  };
  GtkWidget *shape_buttons_box = dt_masks_shape_buttons_create(&shape_buttons_config);
  gtk_box_pack_start(GTK_BOX(hbox_shapes), shape_buttons_box, FALSE, FALSE, 0);
  g->bt_circle = shape_buttons[DT_MASKS_SHAPE_INDEX_CIRCLE];
  g->bt_ellipse = shape_buttons[DT_MASKS_SHAPE_INDEX_ELLIPSE];
  g->bt_polygon = shape_buttons[DT_MASKS_SHAPE_INDEX_POLYGON];
  g->bt_brush = shape_buttons[DT_MASKS_SHAPE_INDEX_BRUSH];
 
  // algorithm toolbar
  GtkWidget *hbox_algo = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
 
  gtk_box_pack_start(GTK_BOX(hbox_algo), dt_ui_label_new(_("algorithms:")), FALSE, TRUE, 0);
 
  g->bt_blur = dt_iop_togglebutton_new(
      self, N_("tools"), N_("Activate blur tool"), N_("change algorithm for current form"),
      G_CALLBACK(rt_select_algorithm_callback), TRUE, 0, 0, dtgtk_cairo_paint_tool_blur, hbox_algo);
 
  g->bt_fill = dt_iop_togglebutton_new(
      self, N_("tools"), N_("Activate fill tool"), N_("change algorithm for current form"),
      G_CALLBACK(rt_select_algorithm_callback), TRUE, 0, 0, dtgtk_cairo_paint_tool_fill, hbox_algo);
 
  g->bt_clone = dt_iop_togglebutton_new(
      self, N_("tools"), N_("Activate cloning tool"), N_("change algorithm for current form"),
      G_CALLBACK(rt_select_algorithm_callback), TRUE, 0, 0, dtgtk_cairo_paint_tool_clone, hbox_algo);
 
  g->bt_heal = dt_iop_togglebutton_new(
      self, N_("tools"), N_("Activate healing tool"), N_("change algorithm for current form"),
      G_CALLBACK(rt_select_algorithm_callback), TRUE, 0, 0, dtgtk_cairo_paint_tool_heal, hbox_algo);
 
  // overwrite tooltip ourself to handle shift+click
  gchar *tt2 = g_strdup_printf("%s\n%s", _("Ctrl+click to change tool for current form"),
                               _("Shift+click to set the tool as default"));
  gchar *tt = g_strdup_printf("%s\n%s", _("Activate blur tool"), tt2);
  gtk_widget_set_tooltip_text(g->bt_blur, tt);
  dt_free(tt);
  tt = g_strdup_printf("%s\n%s", _("Activate fill tool"), tt2);
  gtk_widget_set_tooltip_text(g->bt_fill, tt);
  dt_free(tt);
  tt = g_strdup_printf("%s\n%s", _("Activate cloning tool"), tt2);
  gtk_widget_set_tooltip_text(g->bt_clone, tt);
  dt_free(tt);
  tt = g_strdup_printf("%s\n%s", _("Activate healing tool"), tt2);
  gtk_widget_set_tooltip_text(g->bt_heal, tt);
  dt_free(tt);
  dt_free(tt2);
 
  // wavelet decompose bar labels
  GtkWidget *grid_wd_labels = gtk_grid_new();
  gtk_grid_set_column_homogeneous(GTK_GRID(grid_wd_labels), FALSE);
 
  gtk_grid_attach(GTK_GRID(grid_wd_labels), dt_ui_label_new(_("scales:")), 0, 0, 1, 1);
  g->lbl_num_scales = GTK_LABEL(dt_ui_label_new(NULL));
  gtk_label_set_width_chars(g->lbl_num_scales, 2);
  gtk_grid_attach(GTK_GRID(grid_wd_labels), GTK_WIDGET(g->lbl_num_scales), 1, 0, 1, 1);
 
  gtk_grid_attach(GTK_GRID(grid_wd_labels), dt_ui_label_new(_("current:")), 0, 1, 1, 1);
  g->lbl_curr_scale = GTK_LABEL(dt_ui_label_new(NULL));
  gtk_label_set_width_chars(g->lbl_curr_scale, 2);
  gtk_grid_attach(GTK_GRID(grid_wd_labels), GTK_WIDGET(g->lbl_curr_scale), 1, 1, 1, 1);
 
  gtk_grid_attach(GTK_GRID(grid_wd_labels), dt_ui_label_new(_("merge from:")), 0, 2, 1, 1);
  g->lbl_merge_from_scale = GTK_LABEL(dt_ui_label_new(NULL));
  gtk_label_set_width_chars(g->lbl_merge_from_scale, 2);
  gtk_grid_attach(GTK_GRID(grid_wd_labels), GTK_WIDGET(g->lbl_merge_from_scale), 1, 2, 1, 1);
 
  // wavelet decompose bar
  g->wd_bar = gtk_drawing_area_new();
 
  gtk_widget_set_tooltip_text(g->wd_bar, _("Top slider adjusts where the merge scales start\n"
                                           "Bottom slider adjusts the number of scales\n"
                                           "Dot indicates the current scale\n"
                                           "Top line indicates that the scale is visible at current zoom level\n"
                                           "Bottom line indicates that the scale has shapes on it"));
  g_signal_connect(G_OBJECT(g->wd_bar), "draw", G_CALLBACK(rt_wdbar_draw), self);
  g_signal_connect(G_OBJECT(g->wd_bar), "motion-notify-event", G_CALLBACK(rt_wdbar_motion_notify), self);
  g_signal_connect(G_OBJECT(g->wd_bar), "leave-notify-event", G_CALLBACK(rt_wdbar_leave_notify), self);
  g_signal_connect(G_OBJECT(g->wd_bar), "button-press-event", G_CALLBACK(rt_wdbar_button_press), self);
  g_signal_connect(G_OBJECT(g->wd_bar), "button-release-event", G_CALLBACK(rt_wdbar_button_release), self);
  g_signal_connect(G_OBJECT(g->wd_bar), "scroll-event", G_CALLBACK(rt_wdbar_scrolled), self);
  gtk_widget_add_events(GTK_WIDGET(g->wd_bar), GDK_POINTER_MOTION_MASK
                                                   | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK
                                                   | GDK_LEAVE_NOTIFY_MASK | dt_widget_scroll_mask());
  gtk_widget_set_size_request(g->wd_bar, -1, DT_PIXEL_APPLY_DPI(40));
 
  // toolbar display current scale / cut&paste / suppress&display masks
  GtkWidget *hbox_scale = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
 
  // display & suppress masks
  g->bt_showmask = dt_iop_togglebutton_new(self, N_("editing"), N_("Display masks"), NULL,
                                           G_CALLBACK(rt_showmask_callback), TRUE, 0, 0,
                                           dtgtk_cairo_paint_showmask, hbox_scale);
 
 
  g->bt_suppress = dt_iop_togglebutton_new(self, N_("editing"), N_("Temporarily switch off shapes"), NULL,
                                           G_CALLBACK(rt_suppress_callback), TRUE, 0, 0,
                                           dtgtk_cairo_paint_eye_toggle, hbox_scale);
 
 
  gtk_box_pack_end(GTK_BOX(hbox_scale), gtk_grid_new(), TRUE, TRUE, 0);
 
  // copy/paste shapes
  g->bt_paste_scale = dt_iop_togglebutton_new(self, N_("editing"), N_("Paste cut shapes to current scale"), NULL,
                                              G_CALLBACK(rt_copypaste_scale_callback), TRUE, 0, 0,
                                              dtgtk_cairo_paint_paste_forms, hbox_scale);
 
  g->bt_copy_scale = dt_iop_togglebutton_new(self, N_("editing"), N_("Cut shapes from current scale"), NULL,
                                             G_CALLBACK(rt_copypaste_scale_callback), TRUE, 0, 0,
                                             dtgtk_cairo_paint_cut_forms, hbox_scale);
 
  gtk_box_pack_end(GTK_BOX(hbox_scale), gtk_grid_new(), TRUE, TRUE, 0);
 
  // display final image/current scale
  g->bt_display_wavelet_scale = dt_iop_togglebutton_new(self, N_("editing"), N_("Display wavelet scale"), NULL,
                                                        G_CALLBACK(rt_display_wavelet_scale_callback), TRUE, 0, 0,
                                                        dtgtk_cairo_paint_display_wavelet_scale, hbox_scale);
 
 
  // preview single scale
  g->vbox_preview_scale = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
 
  GtkWidget *lbl_psc = dt_ui_section_label_new(_("preview single scale"));
  gtk_box_pack_start(GTK_BOX(g->vbox_preview_scale), lbl_psc, FALSE, TRUE, 0);
 
  GtkWidget *prev_lvl = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
 
  // gradient slider
  #define NEUTRAL_GRAY 0.5
  static const GdkRGBA _gradient_L[]
      = { { 0, 0, 0, 1.0 }, { NEUTRAL_GRAY, NEUTRAL_GRAY, NEUTRAL_GRAY, 1.0 } };
  g->preview_levels_gslider = DTGTK_GRADIENT_SLIDER_MULTIVALUE(
      dtgtk_gradient_slider_multivalue_new_with_color_and_name(_gradient_L[0], _gradient_L[1], 3, "preview-levels"));
  gtk_widget_set_tooltip_text(GTK_WIDGET(g->preview_levels_gslider), _("Adjust preview levels"));
  dtgtk_gradient_slider_multivalue_set_marker(g->preview_levels_gslider, GRADIENT_SLIDER_MARKER_LOWER_OPEN_BIG, 0);
  dtgtk_gradient_slider_multivalue_set_marker(g->preview_levels_gslider, GRADIENT_SLIDER_MARKER_LOWER_FILLED_BIG, 1);
  dtgtk_gradient_slider_multivalue_set_marker(g->preview_levels_gslider, GRADIENT_SLIDER_MARKER_LOWER_OPEN_BIG, 2);
  (g->preview_levels_gslider)->scale_callback = rt_gslider_scale_callback;
  double vdefault[3] = {RETOUCH_PREVIEW_LVL_MIN, (RETOUCH_PREVIEW_LVL_MIN + RETOUCH_PREVIEW_LVL_MAX) / 2.0, RETOUCH_PREVIEW_LVL_MAX};
  dtgtk_gradient_slider_multivalue_set_values(g->preview_levels_gslider, vdefault);
  dtgtk_gradient_slider_multivalue_set_resetvalues(g->preview_levels_gslider, vdefault);
  (g->preview_levels_gslider)->markers_type = PROPORTIONAL_MARKERS;
  (g->preview_levels_gslider)->min_spacing = 0.05;
  g_signal_connect(G_OBJECT(g->preview_levels_gslider), "value-changed", G_CALLBACK(rt_gslider_changed), self);
 
  gtk_box_pack_start(GTK_BOX(prev_lvl), GTK_WIDGET(g->preview_levels_gslider), TRUE, TRUE, 0);
 
  // auto-levels button
  g->bt_auto_levels = dt_iop_togglebutton_new(self, N_("editing"), N_("Auto levels"), NULL,
                                              G_CALLBACK(rt_auto_levels_callback), TRUE, 0, 0,
                                              dtgtk_cairo_paint_auto_levels, prev_lvl);
 
  gtk_box_pack_start(GTK_BOX(g->vbox_preview_scale), prev_lvl, TRUE, TRUE, 0);
 
  // shapes selected (label)
  GtkWidget *hbox_shape_sel = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  GtkWidget *label1 = gtk_label_new(_("shape selected:"));
  gtk_label_set_ellipsize(GTK_LABEL(label1), PANGO_ELLIPSIZE_START);
  gtk_box_pack_start(GTK_BOX(hbox_shape_sel), label1, FALSE, TRUE, 0);
  g->label_form_selected = GTK_LABEL(gtk_label_new("-1"));
  gtk_widget_set_tooltip_text(hbox_shape_sel,
                              _("Click on a shape to select it,\nto unselect click on an empty space"));
  gtk_box_pack_start(GTK_BOX(hbox_shape_sel), GTK_WIDGET(g->label_form_selected), FALSE, TRUE, 0);
 
  // fill properties
  g->vbox_fill = self->gui->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
 
  g->cmb_fill_mode = dt_bauhaus_combobox_from_params(self, "fill_mode");
  gtk_widget_set_tooltip_text(g->cmb_fill_mode, _("Erase the detail or fills with chosen color"));
 
  // color for fill algorithm
  GdkRGBA color
      = (GdkRGBA){.red = p->fill_color[0], .green = p->fill_color[1], .blue = p->fill_color[2], .alpha = 1.0 };
 
  g->hbox_color_pick = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  GtkWidget *lbl_fill_color = dt_ui_label_new(_("fill color: "));
  gtk_box_pack_start(GTK_BOX(g->hbox_color_pick), lbl_fill_color, FALSE, TRUE, 0);
 
  g->colorpick = gtk_color_button_new_with_rgba(&color);
  gtk_color_chooser_set_use_alpha(GTK_COLOR_CHOOSER(g->colorpick), FALSE);
  gtk_color_button_set_title(GTK_COLOR_BUTTON(g->colorpick), _("Select fill color"));
  gtk_widget_set_tooltip_text(g->colorpick, _("Select fill color"));
  g_signal_connect(G_OBJECT(g->colorpick), "color-set", G_CALLBACK(rt_colorpick_color_set_callback), self);
  gtk_box_pack_start(GTK_BOX(g->hbox_color_pick), GTK_WIDGET(g->colorpick), TRUE, TRUE, 0);
 
  g->colorpicker = dt_color_picker_new(self, DT_COLOR_PICKER_POINT, g->hbox_color_pick);
  gtk_widget_set_tooltip_text(g->colorpicker, _("Pick fill color from image"));
 
  gtk_box_pack_start(GTK_BOX(g->vbox_fill), g->hbox_color_pick, TRUE, TRUE, 0);
 
  g->sl_fill_brightness = dt_bauhaus_slider_from_params(self, "fill_brightness");
  dt_bauhaus_slider_set_digits(g->sl_fill_brightness, 4);
  dt_bauhaus_slider_set_format(g->sl_fill_brightness, "%");
  gtk_widget_set_tooltip_text(g->sl_fill_brightness,
                              _("Adjusts color brightness to fine-tune it. Works with erase as well"));
 
  // blur properties
  g->vbox_blur = self->gui->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
 
  g->cmb_blur_type = dt_bauhaus_combobox_from_params(self, "blur_type");
  gtk_widget_set_tooltip_text(g->cmb_blur_type, _("Type for the blur algorithm"));
 
  g->sl_blur_radius = dt_bauhaus_slider_from_params(self, "blur_radius");
  dt_bauhaus_slider_set_format(g->sl_blur_radius, " px");
  gtk_widget_set_tooltip_text(g->sl_blur_radius, _("Radius of the selected blur type"));
 
  // mask opacity
  g->sl_mask_opacity = dt_bauhaus_slider_new_with_range(dt_bauhaus_get_global(), DT_GUI_MODULE(self), 0.0, 1.0, 0, 1., 3);
  dt_bauhaus_widget_set_label(g->sl_mask_opacity, N_("Mask opacity"));
  dt_bauhaus_slider_set_format(g->sl_mask_opacity, "%");
  gtk_widget_set_tooltip_text(g->sl_mask_opacity, _("Set the opacity on the selected shape"));
  g_signal_connect(G_OBJECT(g->sl_mask_opacity), "value-changed", G_CALLBACK(rt_mask_opacity_callback), self);
 
  // start building top level widget
  self->gui->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
 
  GtkWidget *lbl_rt_tools = dt_ui_section_label_new(_("retouch tools"));
  gtk_box_pack_start(GTK_BOX(self->gui->widget), lbl_rt_tools, FALSE, TRUE, 0);
 
  // shapes toolbar
  gtk_box_pack_start(GTK_BOX(self->gui->widget), hbox_shapes, TRUE, TRUE, 0);
  // algorithms toolbar
  gtk_box_pack_start(GTK_BOX(self->gui->widget), hbox_algo, TRUE, TRUE, 0);
 
  g->cmb_heal_algorithm = dt_bauhaus_combobox_from_params(self, "heal_algorithm");
  gtk_widget_set_tooltip_text(g->cmb_heal_algorithm,
                              _("- Linear: the source keeps its own noise and texture amplitude,\n"
                                "          a source brighter than the target makes it noisier\n"
                                "- Square root: the source noise is scaled to the brightness of the target"));
 
  // wavelet decompose
  GtkWidget *lbl_wd = dt_ui_section_label_new(_("wavelet decompose"));
  gtk_box_pack_start(GTK_BOX(self->gui->widget), lbl_wd, FALSE, TRUE, 0);
 
  // wavelet decompose bar & labels
  gtk_box_pack_start(GTK_BOX(self->gui->widget), grid_wd_labels, TRUE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(self->gui->widget), g->wd_bar, TRUE, TRUE, DT_PIXEL_APPLY_DPI(3));
 
  // preview scale & cut/paste scale
  gtk_box_pack_start(GTK_BOX(self->gui->widget), hbox_scale, TRUE, TRUE, 0);
 
  // preview single scale
  gtk_box_pack_start(GTK_BOX(self->gui->widget), g->vbox_preview_scale, TRUE, TRUE, 0);
 
  // shapes
  GtkWidget *lbl_shapes = dt_ui_section_label_new(_("shapes"));
  gtk_box_pack_start(GTK_BOX(self->gui->widget), lbl_shapes, FALSE, TRUE, 0);
 
  // shape selected
  gtk_box_pack_start(GTK_BOX(self->gui->widget), hbox_shape_sel, TRUE, TRUE, 0);
  // blur radius
  gtk_box_pack_start(GTK_BOX(self->gui->widget), g->vbox_blur, TRUE, TRUE, 0);
  // fill color
  gtk_box_pack_start(GTK_BOX(self->gui->widget), g->vbox_fill, TRUE, TRUE, 0);
  // mask (shape) opacity
  gtk_box_pack_start(GTK_BOX(self->gui->widget), g->sl_mask_opacity, TRUE, TRUE, 0);
 
  /* add signal handler for preview pipe finish to redraw the preview */
  DT_DEBUG_CONTROL_SIGNAL_CONNECT(dt_control_signal_get_global(), DT_SIGNAL_DEVELOP_UI_PIPE_FINISHED,
                            G_CALLBACK(rt_develop_ui_pipe_finished_callback), self);
}
 
void gui_reset(struct dt_iop_module_t *self)
{
  // hide the previous masks
  dt_masks_reset_form_gui(self->dev);
  // set the algo to the default one
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
  p->algorithm = dt_conf_get_int("plugins/darkroom/retouch/default_algo");
}
 
void reload_defaults(dt_iop_module_t *self)
{
  // set the algo to the default one
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->default_params;
  p->algorithm = dt_conf_get_int("plugins/darkroom/retouch/default_algo");
}
 
void gui_cleanup(dt_iop_module_t *self)
{
  DT_DEBUG_CONTROL_SIGNAL_DISCONNECT(dt_control_signal_get_global(), G_CALLBACK(rt_develop_ui_pipe_finished_callback), self);
 
  IOP_GUI_FREE;
}
 
void modify_roi_out(struct dt_iop_module_t *self, const struct dt_dev_pixelpipe_t *pipe,
                    struct dt_dev_pixelpipe_iop_t *piece, dt_iop_roi_t *roi_out,
                    const dt_iop_roi_t *roi_in)
{
  *roi_out = *roi_in;
}
 
// The input rectangle retouch grows while planning, as left/top/right/bottom edges.
typedef struct rt_roi_bounds_t
{
  int x;
  int y;
  int r;
  int b;
} rt_roi_bounds_t;
 
// Grow the bounds to cover [left, right] x [top, bottom].
static void rt_roi_bounds_include(rt_roi_bounds_t *const bounds, const float left, const float top,
                                  const float right, const float bottom)
{
  bounds->y = fminf(top, bounds->y);
  bounds->x = fminf(left, bounds->x);
  bounds->r = fmaxf(right, bounds->r);
  bounds->b = fmaxf(bottom, bounds->b);
}
 
// The members of the module's drawn mask, resolved in the run's snapshot. NULL when it has none.
static const GList *rt_pipe_group_members(const dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece)
{
  const dt_develop_blend_params_t *bp = (const dt_develop_blend_params_t *)piece->blendop_data;
  const dt_masks_form_t *grp = dt_masks_get_from_id_in_pipe(pipe, bp->mask_id);
  return (!IS_NULL_PTR(grp) && (grp->type & DT_MASKS_GROUP)) ? grp->points : NULL;
}
 
// A group member's shape, with its id and its slot in rt_forms[]. NULL when the member names no
// shape, when the params do not know the shape yet, or when the snapshot does not hold it.
static dt_masks_form_t *rt_pipe_member_form(const dt_dev_pixelpipe_t *pipe, const dt_iop_retouch_params_t *p,
                                            const GList *member, int *formid, int *index)
{
  const dt_masks_form_group_t *grpt = (const dt_masks_form_group_t *)member->data;
  *formid = IS_NULL_PTR(grpt) ? 0 : grpt->formid;
  *index = rt_get_index_from_formid(p, *formid);
  if(*index < 0) return NULL;
  return dt_masks_get_from_id_in_pipe(pipe, *formid);
}
 
static gboolean rt_algo_needs_source(const dt_iop_retouch_algo_type_t algo)
{
  return algo == DT_IOP_RETOUCH_HEAL || algo == DT_IOP_RETOUCH_CLONE;
}
 
// Grow the bounds to cover an area shifted by (dx, dy).
static void rt_roi_bounds_include_area(rt_roi_bounds_t *const bounds, const dt_masks_area_t *area, const float dx,
                                       const float dy)
{
  rt_roi_bounds_include(bounds, area->x + dx, area->y + dy, (area->x + area->width) + dx,
                        (area->y + area->height) + dy);
}
 
// Blur reads `overlap` pixels around the area: grow the bounds towards it on each side it
// reaches past, never beyond the area itself.
static void rt_roi_bounds_grow_for_blur(rt_roi_bounds_t *const bounds, const dt_masks_area_t *area,
                                        const int overlap)
{
  if(bounds->y > area->y) bounds->y = MAX(bounds->y - overlap, area->y);
  if(bounds->x > area->x) bounds->x = MAX(bounds->x - overlap, area->x);
  if(bounds->r < area->x + area->width) bounds->r = MAX(bounds->r + overlap, area->x + area->width);
  if(bounds->b < area->y + area->height) bounds->b = MAX(bounds->b + overlap, area->y + area->height);
}
 
// The part of a rasterisation's identity that is not the shape: the transformation chain above
// this node, the sensor dimensions the masks code works in, and the rasterisation step a brush
// honours. The last two reach no hash of the pipeline's own. INVALID disables the memo.
static uint64_t rt_geometry_base_hash(const dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece)
{
  static const char cache_tag[] = "retouch:geometry";
  if(piece->upstream_hash == DT_PIXELPIPE_CACHE_HASH_INVALID) return DT_PIXELPIPE_CACHE_HASH_INVALID;
 
  uint64_t hash = dt_hash(piece->upstream_hash, cache_tag, sizeof(cache_tag));
  /* This module's own place in the pipe: it is the bound the back-transform stops at, and
   * upstream_hash only describes what sits before it. */
  hash = dt_hash(hash, (const char *)&piece->module->iop_order, sizeof(int));
  hash = dt_hash(hash, (const char *)&pipe->iwidth, sizeof(pipe->iwidth));
  hash = dt_hash(hash, (const char *)&pipe->iheight, sizeof(pipe->iheight));
  const int raster_step = pipe->mask_rasterization_step;
  hash = dt_hash(hash, (const char *)&raster_step, sizeof(raster_step));
  return hash;
}
 
// The same, plus the shape's own geometry.
static uint64_t rt_shape_geometry_hash(const uint64_t base, dt_masks_form_t *const form)
{
  if(base == DT_PIXELPIPE_CACHE_HASH_INVALID || IS_NULL_PTR(form)) return DT_PIXELPIPE_CACHE_HASH_INVALID;
 
  /* A nested group would need its members folded in through the run's form list. It cannot
   * reach here -- a group has no get_area(), so dt_masks_get_area() refuses it and the member is
   * skipped -- and a partial hash is worse than no memo, so refuse rather than assume. */
  if(form->type & DT_MASKS_GROUP) return DT_PIXELPIPE_CACHE_HASH_INVALID;
  return dt_masks_form_get_own_hash(base, NULL, form);
}
 
/* What a shape's rasterisation needs before a single pixel is touched: its own bounding box and
 * the box of its clone source, both in sensor coordinates. `rt_compute_roi_in()` and
 * `rt_extend_roi_in_*()` ask for these on every ROI planning pass, the second pair once per
 * ordered PAIR of shapes, and for a brush or a polygon each answer regenerates the whole
 * outline. They depend on the shape and on the chain above the module, never on the viewport or
 * on a pixel, so one memo entry per shape serves every pass and every pipe. */
typedef struct rt_shape_geometry_t
{
  dt_masks_area_t area;   // the shape itself
  dt_masks_area_t source; // its clone source, meaningful only when `has_source`
  int32_t has_area;
  int32_t has_source;
} rt_shape_geometry_t;
 
// Which of the two boxes a call needs.
typedef enum rt_box_t
{
  RT_BOX_AREA = 0,
  RT_BOX_SOURCE
} rt_box_t;
 
static void rt_compute_shape_geometry(const rt_masks_ctx_t *const ctx, dt_masks_form_t *form,
                                      rt_shape_geometry_t *out)
{
  *out = (rt_shape_geometry_t){ { 0 } };
  out->has_area = (dt_masks_get_area(ctx->self, ctx->pipe, ctx->piece, form, &out->area) == DT_MASKS_RASTER_OK);
  /* A shape that is not a clone has no source area -- an absence, not a failure. */
  out->has_source
      = (dt_masks_get_source_area(ctx->self, ctx->pipe, ctx->piece, form, &out->source) == DT_MASKS_RASTER_OK);
}
 
// The one box a caller with no memo asked for. Computing the other as well would be a straight
// loss here: nothing would read it, and for a brush it is a second outline generation.
static gboolean rt_compute_shape_box(const rt_masks_ctx_t *const ctx, dt_masks_form_t *form,
                                     const rt_box_t want, dt_masks_area_t *out)
{
  return ((want == RT_BOX_SOURCE) ? dt_masks_get_source_area(ctx->self, ctx->pipe, ctx->piece, form, out)
                                  : dt_masks_get_area(ctx->self, ctx->pipe, ctx->piece, form, out))
         == DT_MASKS_RASTER_OK;
}
 
// One of the shape's boxes, from the memo when there is one. FALSE when the shape has no such box.
static gboolean rt_shape_box(const rt_masks_ctx_t *const ctx, dt_masks_form_t *form,
                             const uint64_t shape_hash, const rt_box_t want, dt_masks_area_t *out)
{
  if(shape_hash == DT_PIXELPIPE_CACHE_HASH_INVALID)
  {
    if(ctx->stats) ctx->stats->boxes_computed++;
    return rt_compute_shape_box(ctx, form, want, out);
  }
 
  static const char cache_tag[] = "boxes";
  const uint64_t hash = dt_hash(shape_hash, cache_tag, sizeof(cache_tag));
 
  void *data = NULL;
  struct dt_pixel_cache_entry_t *entry = NULL;
  const int created = dt_dev_pixelpipe_cache_get(hash, sizeof(rt_shape_geometry_t), "retouch shape boxes",
                                                 ctx->pipe->type, TRUE, &data, &entry);
  if(IS_NULL_PTR(data) || IS_NULL_PTR(entry))
  {
    if(!IS_NULL_PTR(entry))
    {
      if(created) dt_dev_pixelpipe_cache_wrlock_entry(FALSE, entry);
      dt_dev_pixelpipe_cache_ref_count_entry(FALSE, entry);
    }
    if(ctx->stats) ctx->stats->boxes_computed++;
    return rt_compute_shape_box(ctx, form, want, out);
  }
 
  rt_shape_geometry_t boxes;
  if(ctx->stats) { if(created) ctx->stats->boxes_computed++; else ctx->stats->boxes_hit++; }
  if(created)
  {
    // both, once: the other box is asked for by another pass over the same shapes
    rt_compute_shape_geometry(ctx, form, &boxes);
    memcpy(data, &boxes, sizeof(rt_shape_geometry_t));
    dt_dev_pixelpipe_cache_wrlock_entry(FALSE, entry);
  }
  else
  {
    dt_dev_pixelpipe_cache_rdlock_entry(TRUE, entry);
    memcpy(&boxes, data, sizeof(rt_shape_geometry_t));
    dt_dev_pixelpipe_cache_rdlock_entry(FALSE, entry);
  }
  dt_dev_pixelpipe_cache_ref_count_entry(FALSE, entry);
 
  *out = (want == RT_BOX_SOURCE) ? boxes.source : boxes.area;
  return (want == RT_BOX_SOURCE) ? boxes.has_source : boxes.has_area;
}
 
static void rt_compute_roi_in(const rt_masks_ctx_t *const ctx, const dt_iop_roi_t *roi_in,
                              rt_roi_bounds_t *const bounds)
{
  const dt_iop_retouch_params_t *p = (const dt_iop_retouch_params_t *)ctx->piece->data;
  const uint64_t base_hash = rt_geometry_base_hash(ctx->pipe, ctx->piece);
 
  for(const GList *members = rt_pipe_group_members(ctx->pipe, ctx->piece); members;
      members = g_list_next(members))
  {
    int formid = 0;
    int index = -1;
    dt_masks_form_t *form = rt_pipe_member_form(ctx->pipe, p, members, &formid, &index);
    if(IS_NULL_PTR(form) || p->rt_forms[index].algorithm == DT_IOP_RETOUCH_FILL) continue;
 
    // the area of the form, skipped when outside the roi
    dt_masks_area_t area;
    if(!rt_shape_box(ctx, form, rt_shape_geometry_hash(base_hash, form), RT_BOX_AREA, &area))
      continue;
    dt_masks_area_scale(&area, roi_in->scale);
    if(!dt_masks_area_intersects(&area, roi_in)) continue;
 
    const dt_iop_retouch_form_data_t *data = &p->rt_forms[index];
 
    // heal needs the entire area
    if(data->algorithm == DT_IOP_RETOUCH_HEAL) rt_roi_bounds_include_area(bounds, &area, 0.f, 0.f);
 
    // blur needs an overlap of 4 * radius (scaled)
    if(data->algorithm == DT_IOP_RETOUCH_BLUR)
      rt_roi_bounds_grow_for_blur(bounds, &area, ceilf(4 * (data->blur_radius * roi_in->scale)));
 
    // heal and clone need both source and destination areas
    float dx = 0.f;
    float dy = 0.f;
    if(rt_algo_needs_source(data->algorithm)
       && rt_masks_get_delta_to_destination(ctx, roi_in, form, &dx, &dy, data->distort_mode))
      rt_roi_bounds_include_area(bounds, &area, -dx, -dy);
  }
}
 
// for a given form, if a previous clone/heal destination intersects the source area,
// include that area in roi_in too
static void rt_extend_roi_in_from_source_clones(const rt_masks_ctx_t *const ctx, const dt_iop_roi_t *roi_in,
                                                const int formid_src, const dt_masks_area_t *src,
                                                rt_roi_bounds_t *const bounds)
{
  const dt_iop_retouch_params_t *p = (const dt_iop_retouch_params_t *)ctx->piece->data;
  const uint64_t base_hash = rt_geometry_base_hash(ctx->pipe, ctx->piece);
 
  for(const GList *members = rt_pipe_group_members(ctx->pipe, ctx->piece); members;
      members = g_list_next(members))
  {
    int formid = 0;
    int index = -1;
    dt_masks_form_t *form = rt_pipe_member_form(ctx->pipe, p, members, &formid, &index);
 
    // just need the previous forms
    if(formid == formid_src) break;
    if(IS_NULL_PTR(form) || !rt_algo_needs_source(p->rt_forms[index].algorithm)) continue;
 
    // the source area
    dt_masks_area_t area;
    if(!rt_shape_box(ctx, form, rt_shape_geometry_hash(base_hash, form), RT_BOX_SOURCE, &area))
      continue;
    dt_masks_area_scale(&area, roi_in->scale);
 
    // the destination area
    float dx = 0.f;
    float dy = 0.f;
    if(!rt_masks_get_delta_to_destination(ctx, roi_in, form, &dx, &dy, p->rt_forms[index].distort_mode))
      continue;
 
    const int ft_dest = area.y + dy;
    const int fl_dest = area.x + dx;
 
    // does the destination of this form intersect the source of formid_src?
    const int intersects = !(ft_dest + area.height < src->y || src->y + src->height < ft_dest
                             || fl_dest + area.width < src->x || src->x + src->width < fl_dest);
    if(intersects)
    {
      // both source and destination areas
      rt_roi_bounds_include_area(bounds, &area, 0.f, 0.f);
      rt_roi_bounds_include_area(bounds, &area, dx, dy);
    }
  }
}
 
// for clone and heal, if the source area is the destination from another clone/heal,
// we also need the area from that previous clone/heal
static void rt_extend_roi_in_for_clone(const rt_masks_ctx_t *const ctx, const dt_iop_roi_t *roi_in,
                                       rt_roi_bounds_t *const bounds)
{
  const dt_iop_retouch_params_t *p = (const dt_iop_retouch_params_t *)ctx->piece->data;
  const uint64_t base_hash = rt_geometry_base_hash(ctx->pipe, ctx->piece);
 
  for(const GList *members = rt_pipe_group_members(ctx->pipe, ctx->piece); members;
      members = g_list_next(members))
  {
    int formid = 0;
    int index = -1;
    dt_masks_form_t *form = rt_pipe_member_form(ctx->pipe, p, members, &formid, &index);
    if(IS_NULL_PTR(form) || !rt_algo_needs_source(p->rt_forms[index].algorithm)) continue;
 
    // the source area
    dt_masks_area_t src;
    if(!rt_shape_box(ctx, form, rt_shape_geometry_hash(base_hash, form), RT_BOX_SOURCE, &src))
      continue;
    dt_masks_area_scale(&src, roi_in->scale);
 
    // we only want to process forms already in roi_in
    const int intersects = !(bounds->b < src.y || src.y + src.height < bounds->y || bounds->r < src.x
                             || src.x + src.width < bounds->x);
    if(intersects) rt_extend_roi_in_from_source_clones(ctx, roi_in, formid, &src, bounds);
  }
}
 
// needed if mask dest is in roi and mask src is not
void modify_roi_in(struct dt_iop_module_t *self, const struct dt_dev_pixelpipe_t *pipe,
                   struct dt_dev_pixelpipe_iop_t *piece, const dt_iop_roi_t *roi_out,
                   dt_iop_roi_t *roi_in)
{
  *roi_in = *roi_out;
 
  rt_roi_bounds_t bounds = { .x = roi_in->x, .y = roi_in->y,
                             .r = roi_in->width + roi_in->x, .b = roi_in->height + roi_in->y };
 
  /* Every pass of the loop below walks the members once per member -- O(shapes squared) source
   * areas -- so this is where a shape-heavy image spends its planning, and the pipeline's own
   * `processed` line does not cover any of it. See rt_memo_stats_t. */
  rt_memo_stats_t counters = { 0 };
  const gboolean counting = rt_perf_enabled();
  const rt_masks_ctx_t ctx = { self, pipe, piece, counting ? &counters : NULL };
  const double planning_start = counting ? dt_get_wtime() : 0.0;
  int passes = 0;
 
  rt_compute_roi_in(&ctx, roi_in, &bounds);
 
  rt_roi_bounds_t previous = { -1, -1, -1, -1 };
  while(memcmp(&bounds, &previous, sizeof(bounds)))
  {
    previous = bounds;
    passes++;
    rt_extend_roi_in_for_clone(&ctx, roi_in, &bounds);
  }
 
  if(counting)
    dt_print(DT_DEBUG_PERF,
             "[retouch] %-8s modify_roi_in: %d stabilisation pass(es), boxes %d (%d memo / %d rasterised),"
             " %.3f s\n",
             dt_pixelpipe_name(pipe->type), passes, counters.boxes_hit + counters.boxes_computed,
             counters.boxes_hit, counters.boxes_computed, dt_get_wtime() - planning_start);
 
  // now we set the values
  const float scwidth = piece->buf_in.width * roi_in->scale, scheight = piece->buf_in.height * roi_in->scale;
  roi_in->x = CLAMP(bounds.x, 0, scwidth - 1);
  roi_in->y = CLAMP(bounds.y, 0, scheight - 1);
  roi_in->width = CLAMP(bounds.r - roi_in->x, 1, scwidth + .5f - roi_in->x);
  roi_in->height = CLAMP(bounds.b - roi_in->y, 1, scheight + .5f - roi_in->y);
}
 
//--------------------------------------------------------------------------------------------------
// process
//--------------------------------------------------------------------------------------------------
 
static void image_rgb2lab(float *img_src, const int width, const int height, const int ch, const int use_sse)
{
  const int stride = width * height * ch;
  __OMP_PARALLEL_FOR__()
  for(int i = 0; i < stride; i += ch)
  {
    dt_aligned_pixel_t XYZ;
 
    dt_linearRGB_to_XYZ(img_src + i, XYZ);
    dt_XYZ_to_Lab(XYZ, img_src + i);
  }
}
 
static void image_lab2rgb(float *img_src, const int width, const int height, const int ch, const int use_sse)
{
  const int stride = width * height * ch;
  __OMP_PARALLEL_FOR__()
  for(int i = 0; i < stride; i += ch)
  {
    dt_aligned_pixel_t XYZ;
 
    dt_Lab_to_XYZ(img_src + i, XYZ);
    dt_XYZ_to_linearRGB(XYZ, img_src + i);
  }
}
 
__DT_CLONE_TARGETS__
static void rt_process_stats(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe,
                             float *const img_src, const int width, const int height, const int ch, float levels[3])
{
  const int size = width * height * ch;
  float l_max = -INFINITY;
  float l_min = INFINITY;
  float l_sum = 0.f;
  int count = 0;
  const dt_iop_order_iccprofile_info_t *const work_profile = dt_ioppr_get_pipe_work_profile_info(pipe);
  __OMP_PARALLEL_FOR__(reduction(+ : count, l_sum) reduction(max : l_max) reduction(min : l_min))
  for(int i = 0; i < size; i += ch)
  {
    dt_aligned_pixel_t Lab = { 0 };
 
    if(work_profile)
    {
      dt_ioppr_rgb_matrix_to_lab(img_src + i, Lab, work_profile->matrix_in_transposed,
                                  work_profile->lut_in, work_profile->unbounded_coeffs_in,
                                  work_profile->lutsize, work_profile->nonlinearlut);
    }
    else
    {
      dt_aligned_pixel_t XYZ;
      dt_linearRGB_to_XYZ(img_src + i, XYZ);
      dt_XYZ_to_Lab(XYZ, Lab);
    }
 
    l_max = MAX(l_max, Lab[0]);
    l_min = MIN(l_min, Lab[0]);
    l_sum += Lab[0];
    count++;
  }
 
  levels[0] = l_min / 100.f;
  levels[2] = l_max / 100.f;
  levels[1] = (l_sum / (float)count) / 100.f;
}
 
__DT_CLONE_TARGETS__
static void rt_adjust_levels(dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe,
                             float *img_src, const int width, const int height, const int ch,
                             const float levels[3])
{
  const int size = width * height * ch;
  const dt_iop_order_iccprofile_info_t *const work_profile = dt_ioppr_get_pipe_work_profile_info(pipe);
 
  const float left = levels[0];
  const float middle = levels[1];
  const float right = levels[2];
 
  if(left == RETOUCH_PREVIEW_LVL_MIN && middle == 0.f && right == RETOUCH_PREVIEW_LVL_MAX) return;
 
  const float delta = (right - left) / 2.0f;
  const float mid = left + delta;
  const float tmp = (middle - mid) / delta;
  const float in_inv_gamma = powf(10, tmp);
  __OMP_PARALLEL_FOR__()
  for(int i = 0; i < size; i += ch)
  {
    // The RGB<->Lab/XYZ conversions below store through 4-wide SIMD (dt_apply_transposed_color_matrix
    // et al.), which unconditionally overwrites all 4 lanes of img_src+i even though the color math
    // itself is 3-channel -- the 4th lane ends up holding leftover matrix-multiply output, not the
    // original value. For most pipeline buffers that 4th channel is meaningless padding, but here it
    // is retouch's own mask-display alpha (painted a few lines up the call chain via
    // rt_copy_mask_to_alpha), so silently clobbering it left every "mask display" pixel looking
    // fully transparent whenever a single wavelet scale was also being previewed. Save and restore it
    // around the round trip.
    const float preserved_alpha = img_src[i + 3];
 
    if(!IS_NULL_PTR(work_profile))
    {
      dt_ioppr_rgb_matrix_to_lab(img_src + i, img_src + i, work_profile->matrix_in_transposed,
                                  work_profile->lut_in, work_profile->unbounded_coeffs_in,
                                  work_profile->lutsize, work_profile->nonlinearlut);
    }
    else
    {
      dt_aligned_pixel_t XYZ;
 
      dt_linearRGB_to_XYZ(img_src + i, XYZ);
      dt_XYZ_to_Lab(XYZ, img_src + i);
    }
 
    for(int c = 0; c < 1; c++)
    {
      const float L_in = img_src[i + c] / 100.0f;
 
      if(L_in <= left)
      {
        img_src[i + c] = 0.f;
      }
      else
      {
        const float percentage = (L_in - left) / (right - left);
        img_src[i + c] = 100.0f * powf(percentage, in_inv_gamma);
      }
    }
 
    if(!IS_NULL_PTR(work_profile))
    {
      dt_ioppr_lab_to_rgb_matrix(img_src + i, img_src + i, work_profile->matrix_out_transposed,
                                 work_profile->lut_out, work_profile->unbounded_coeffs_out,
                                 work_profile->lutsize, work_profile->nonlinearlut);;
    }
    else
    {
      dt_aligned_pixel_t XYZ;
 
      dt_Lab_to_XYZ(img_src + i, XYZ);
      dt_XYZ_to_linearRGB(XYZ, img_src + i);
    }
 
    img_src[i + 3] = preserved_alpha;
  }
}
 
#undef RT_WDBAR_INSET
 
#undef RETOUCH_NO_FORMS
#undef RETOUCH_MAX_SCALES
#undef RETOUCH_NO_SCALES
 
#undef RETOUCH_PREVIEW_LVL_MIN
#undef RETOUCH_PREVIEW_LVL_MAX
 
static void rt_intersect_2_rois(const dt_iop_roi_t *const roi_1, const dt_iop_roi_t *const roi_2, const int dx,
                                const int dy,
                                const int padding, dt_iop_roi_t *roi_dest)
{
  const int x_from = MAX(MAX((roi_1->x + 1 - padding), roi_2->x), (roi_2->x + dx));
  const int x_to
      = MIN(MIN((roi_1->x + roi_1->width + 1 + padding), roi_2->x + roi_2->width), (roi_2->x + roi_2->width + dx));
 
  const int y_from = MAX(MAX((roi_1->y + 1 - padding), roi_2->y), (roi_2->y + dy));
  const int y_to = MIN(MIN((roi_1->y + roi_1->height + 1 + padding), (roi_2->y + roi_2->height)),
                       (roi_2->y + roi_2->height + dy));
 
  roi_dest->x = x_from;
  roi_dest->y = y_from;
  roi_dest->width = x_to - x_from;
  roi_dest->height = y_to - y_from;
}
 
__DT_CLONE_TARGETS__
static void rt_copy_in_to_out(const float *const in, const struct dt_iop_roi_t *const roi_in, float *const out,
                              const struct dt_iop_roi_t *const roi_out, const int ch, const int dx, const int dy)
{
  const size_t rowsize = sizeof(float) * ch * MIN(roi_out->width, roi_in->width);
  const int xoffs = roi_out->x - roi_in->x - dx;
  const int yoffs = roi_out->y - roi_in->y - dy;
  const int y_to = MIN(roi_out->height, roi_in->height);
  __OMP_PARALLEL_FOR__()
  for(int y = 0; y < y_to; y++)
  {
    const size_t iindex = ((size_t)(y + yoffs) * roi_in->width + xoffs) * ch;
    const size_t oindex = (size_t)y * roi_out->width * ch;
    float *in1 = (float *)in + iindex;
    float *out1 = (float *)out + oindex;
 
    memcpy(out1, in1, rowsize);
  }
}
 
/* Where a shape's mask lands in the layer, and how big it is there. Pure arithmetic over the
 * shape's full-resolution area and the layer's ROI -- no rasterisation -- which is what lets the
 * memo below size its lookup before deciding whether it has to rasterise anything at all. An
 * empty result (width or height < 1) means the shape draws nothing in this layer. */
static void rt_scaled_mask_roi(const dt_masks_area_t *const area, const dt_iop_roi_t *const roi_in, const int dx,
                               const int dy, const int algo, dt_iop_roi_t *roi_mask_scaled)
{
  const int padding = (algo == DT_IOP_RETOUCH_HEAL) ? 1 : 0;
 
  dt_iop_roi_t roi_mask = { .x = area->x, .y = area->y, .width = area->width, .height = area->height, .scale = 1.f };
 
  *roi_mask_scaled = roi_mask;
  roi_mask_scaled->x = roi_mask.x * roi_in->scale;
  roi_mask_scaled->y = roi_mask.y * roi_in->scale;
  roi_mask_scaled->width = ((roi_mask.width * roi_in->scale) + .5f);
  roi_mask_scaled->height = ((roi_mask.height * roi_in->scale) + .5f);
  roi_mask_scaled->scale = roi_in->scale;
 
  rt_intersect_2_rois(roi_mask_scaled, roi_in, dx, dy, padding, roi_mask_scaled);
}
 
/* Resample the full-resolution mask into `mask_scaled`, which the caller sized from
 * rt_scaled_mask_roi() for the same area and ROI. Writes every pixel of it. */
static void rt_fill_scaled_mask(const float *const mask, const dt_iop_roi_t *const roi_mask,
                                float *const mask_scaled, const dt_iop_roi_t *const roi_mask_scaled,
                                const dt_iop_roi_t *const roi_in)
{
  const int x_to = roi_mask_scaled->width + roi_mask_scaled->x;
  const int y_to = roi_mask_scaled->height + roi_mask_scaled->y;
 
  dt_iop_image_fill(mask_scaled, 0.0f, roi_mask_scaled->width, roi_mask_scaled->height, 1);
  __OMP_PARALLEL_FOR__()
  for(int yy = roi_mask_scaled->y; yy < y_to; yy++)
  {
    const int mask_index = ((int)(yy / roi_in->scale)) - roi_mask->y;
    if(mask_index < 0 || mask_index >= roi_mask->height) continue;
 
    const int mask_scaled_index = (yy - roi_mask_scaled->y) * roi_mask_scaled->width;
 
    const float *m = mask + mask_index * roi_mask->width;
    float *ms = mask_scaled + mask_scaled_index;
 
    for(int xx = roi_mask_scaled->x; xx < x_to; xx++, ms++)
    {
      const int mx = ((int)(xx / roi_in->scale)) - roi_mask->x;
      if(mx < 0 || mx >= roi_mask->width) continue;
 
      *ms = m[mx];
    }
  }
}
 
// img_src and mask_scaled must have the same roi
static void rt_copy_image_masked(float *const img_src, float *img_dest, dt_iop_roi_t *const roi_dest,
                                 float *const mask_scaled, dt_iop_roi_t *const roi_mask_scaled,
                                 const float opacity)
{
  __OMP_PARALLEL_FOR__()
  for(int yy = 0; yy < roi_mask_scaled->height; yy++)
  {
    const int mask_index = yy * roi_mask_scaled->width;
    const int src_index = 4 * mask_index;
    const int dest_index
      = 4 * (((yy + roi_mask_scaled->y - roi_dest->y) * roi_dest->width) + (roi_mask_scaled->x - roi_dest->x));
 
    const float *s = img_src + src_index;
    const float *m = mask_scaled + mask_index;
    float *d = img_dest + dest_index;
 
    for(int xx = 0; xx < roi_mask_scaled->width; xx++)
    {
      const float f = m[xx] * opacity;
      const float f1 = (1.0f - f);
 
      for_each_channel(c,aligned(s,d))
      {
        d[4*xx + c] = d[4*xx + c] * f1 + s[4*xx + c] * f;
      }
    }
  }
}
 
static void rt_copy_mask_to_alpha(float *const img, dt_iop_roi_t *const roi_img, const int ch,
                                  float *const mask_scaled, dt_iop_roi_t *const roi_mask_scaled,
                                  const float opacity)
{
  __OMP_PARALLEL_FOR__()
  for(int yy = 0; yy < roi_mask_scaled->height; yy++)
  {
    const int mask_index = yy * roi_mask_scaled->width;
    const int dest_index
        = (((yy + roi_mask_scaled->y - roi_img->y) * roi_img->width) + (roi_mask_scaled->x - roi_img->x)) * ch;
 
    float *d = img + dest_index;
    const float *m = mask_scaled + mask_index;
 
    for(int xx = 0; xx < roi_mask_scaled->width; xx++, d += ch, m++)
    {
      const float f = (*m) * opacity;
      if(f > d[3]) d[3] = f;
    }
  }
}
 
static void _retouch_fill(float *const in, dt_iop_roi_t *const roi_in, float *const mask_scaled,
                          dt_iop_roi_t *const roi_mask_scaled, const float opacity, const float *const fill_color)
{
  __OMP_PARALLEL_FOR__()
  for(int yy = 0; yy < roi_mask_scaled->height; yy++)
  {
    const int mask_index = yy * roi_mask_scaled->width;
    const int dest_index
        = (((yy + roi_mask_scaled->y - roi_in->y) * roi_in->width) + (roi_mask_scaled->x - roi_in->x)) * 4;
 
    float *d = in + dest_index;
    const float *m = mask_scaled + mask_index;
 
    for(int xx = 0; xx < roi_mask_scaled->width; xx++)
    {
      const float f = m[xx] * opacity;
 
      for_each_channel(c,aligned(d,fill_color))
        d[4*xx + c] = d[4*xx + c] * (1.0f - f) + fill_color[c] * f;
    }
  }
}
 
static int _retouch_clone(float *const in, dt_iop_roi_t *const roi_in, float *const mask_scaled,
                          dt_iop_roi_t *const roi_mask_scaled, const int dx, const int dy, const float opacity)
{
  // alloc temp image to avoid issues when areas self-intersects
  float *img_src = dt_pixelpipe_cache_alloc_align_float_cache((size_t)4 * roi_mask_scaled->width * roi_mask_scaled->height, 0);
  if(IS_NULL_PTR(img_src))
  {
    fprintf(stderr, "retouch_clone: error allocating memory for cloning\n");
    return 1;
  }
 
  // copy source image to tmp
  rt_copy_in_to_out(in, roi_in, img_src, roi_mask_scaled, 4, dx, dy);
 
  // clone it
  rt_copy_image_masked(img_src, in, roi_in, mask_scaled, roi_mask_scaled, opacity);
 
  dt_pixelpipe_cache_free_align(img_src);
  return 0;
}
 
static int _retouch_blur(dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, float *const in,
                         dt_iop_roi_t *const roi_in, float *const mask_scaled,
                         dt_iop_roi_t *const roi_mask_scaled, const float opacity, const int blur_type,
                         const float blur_radius, const int use_sse)
{
  if(fabsf(blur_radius) <= 0.1f) return 0;
 
  const float sigma = blur_radius * roi_in->scale;
 
  float *img_dest = NULL;
 
  // alloc temp image to blur
  img_dest = dt_pixelpipe_cache_alloc_align_float_cache((size_t)4 * roi_mask_scaled->width * roi_mask_scaled->height, 0);
  if(IS_NULL_PTR(img_dest))
  {
    fprintf(stderr, "retouch_blur: error allocating memory for blurring\n");
    return 1;
  }
 
  // copy source image so we blur just the mask area (at least the smallest rect that covers it)
  rt_copy_in_to_out(in, roi_in, img_dest, roi_mask_scaled, 4, 0, 0);
 
  if(blur_type == DT_IOP_RETOUCH_BLUR_GAUSSIAN && fabsf(blur_radius) > 0.1f)
  {
    float Labmax[] = { INFINITY, INFINITY, INFINITY, INFINITY };
    float Labmin[] = { -INFINITY, -INFINITY, -INFINITY, -INFINITY };
 
    dt_gaussian_t *g = dt_gaussian_init(roi_mask_scaled->width, roi_mask_scaled->height, 4, Labmax, Labmin, sigma,
                                        DT_IOP_GAUSSIAN_ZERO);
    if(!IS_NULL_PTR(g))
    {
      dt_gaussian_blur_4c(g, img_dest, img_dest);
      dt_gaussian_free(g);
    }
  }
  else if(blur_type == DT_IOP_RETOUCH_BLUR_BILATERAL && fabsf(blur_radius) > 0.1f)
  {
    const float sigma_r = 100.0f; // does not depend on scale
    const float sigma_s = sigma;
    const float detail = -1.0f; // we want the bilateral base layer
 
    dt_bilateral_t *b = dt_bilateral_init(roi_mask_scaled->width, roi_mask_scaled->height, sigma_s, sigma_r);
    if(b)
    {
      int converted_cst;
      const dt_iop_order_iccprofile_info_t *const work_profile = dt_ioppr_get_pipe_work_profile_info(pipe);
 
      if(!IS_NULL_PTR(work_profile))
        dt_colorspaces_apply_profile(self->op, self->multi_name, img_dest, img_dest, roi_mask_scaled->width,
                                            roi_mask_scaled->height, IOP_CS_RGB, IOP_CS_LAB, &converted_cst,
                                            work_profile);
      else
        image_rgb2lab(img_dest, roi_mask_scaled->width, roi_mask_scaled->height, 4, use_sse);
 
      dt_bilateral_splat(b, img_dest);
      dt_bilateral_blur(b);
      dt_bilateral_slice(b, img_dest, img_dest, detail);
      dt_bilateral_free(b);
 
      if(!IS_NULL_PTR(work_profile))
        dt_colorspaces_apply_profile(self->op, self->multi_name, img_dest, img_dest, roi_mask_scaled->width,
                                            roi_mask_scaled->height, IOP_CS_LAB, IOP_CS_RGB, &converted_cst,
                                            work_profile);
      else
        image_lab2rgb(img_dest, roi_mask_scaled->width, roi_mask_scaled->height, 4, use_sse);
    }
  }
 
  // copy blurred (temp) image to destination image
  rt_copy_image_masked(img_dest, in, roi_in, mask_scaled, roi_mask_scaled, opacity);
 
  dt_pixelpipe_cache_free_align(img_dest);
  return 0;
}
 
// Only the image itself (scale 0) and the wavelet residual carry a light level. Detail scales are
// signed, zero-mean differences, which the square-root domain cannot represent: they heal linearly
// whatever the algorithm.
static dt_heal_domain_t rt_heal_domain(const dt_iop_retouch_params_t *const p, const int scale, const int scales)
{
  const gboolean has_level = (scale == 0 || scale == scales + 1);
  return (p->heal_algorithm == DT_IOP_RETOUCH_HEAL_SQRT && has_level) ? DT_HEAL_DOMAIN_SQRT : DT_HEAL_DOMAIN_LINEAR;
}
 
static int _retouch_heal(float *const in, dt_iop_roi_t *const roi_in, float *const mask_scaled,
                         dt_iop_roi_t *const roi_mask_scaled, const int dx, const int dy, const float opacity,
                         const int max_iter, const dt_heal_domain_t domain)
{
  float *img_src = NULL;
  float *img_dest = NULL;
  int err = 0;
 
  // alloc temp images for source and destination
  img_src  = dt_pixelpipe_cache_alloc_align_float_cache((size_t)4 * roi_mask_scaled->width * roi_mask_scaled->height, 0);
  img_dest = dt_pixelpipe_cache_alloc_align_float_cache((size_t)4 * roi_mask_scaled->width * roi_mask_scaled->height, 0);
  if((IS_NULL_PTR(img_src)) || (IS_NULL_PTR(img_dest)))
  {
    fprintf(stderr, "retouch_heal: error allocating memory for healing\n");
    err = 1;
    goto cleanup;
  }
 
  // copy source and destination to temp images
  rt_copy_in_to_out(in, roi_in, img_src, roi_mask_scaled, 4, dx, dy);
  rt_copy_in_to_out(in, roi_in, img_dest, roi_mask_scaled, 4, 0, 0);
 
  // heal it
  dt_heal(img_src, img_dest, mask_scaled, roi_mask_scaled->width, roi_mask_scaled->height, 4,
          (dt_heal_solver_t){ .max_iter = max_iter, .domain = domain });
 
  // copy healed (temp) image to destination image
  rt_copy_image_masked(img_dest, in, roi_in, mask_scaled, roi_mask_scaled, opacity);
 
cleanup:
  dt_pixelpipe_cache_free_align(img_src);
  dt_pixelpipe_cache_free_align(img_dest);
  return err;
}
 
/* ==============================================================================================
 * Geometric memo: a shape's area, and its mask resampled into the layer.
 *
 * Neither reads a pixel. Both are pure functions of the shape's own geometry and of the
 * distortion chain above this module, so dragging ONE shape leaves every other shape's mask
 * bit-identical -- yet each of them was rasterised again on every frame, twice over: once for
 * the area (`dt_masks_form_is_in_roi()`) and once more inside `dt_masks_get_mask()`, which for a
 * brush or a polygon regenerates the whole outline each time. And it rasterises at full sensor
 * resolution whatever the zoom (`_circle_get_area()` works in `pipe->iwidth`/`iheight`), so a
 * 500 px shape back-transforms 250 000 points through every distorting module above, to then be
 * thrown away at one pixel in a hundred by `rt_fill_scaled_mask()` at fit zoom.
 *
 * Both results are memoised in the shared pixelpipe cache, keyed on `piece->upstream_hash` --
 * the transformation chain above this node, which by construction does NOT move when the
 * module's own parameters do. A miss costs only the work that was being done anyway, so
 * eviction and memory pressure need no handling of their own here.
 *
 * Measured on a 141-shape image, exported at 2000 px: the mask rasterisation this module asks
 * for is 3.5 s, and 3.1 s of it is `modify_roi_in()` -- `rt_extend_roi_in_for_clone()` is
 * O(shapes squared) and calls `dt_masks_get_source_area()` in its inner loop, which for a brush
 * regenerates the whole outline. The box memo below is what turns that inner loop into
 * arithmetic; the mask memo is the smaller half.
 * ============================================================================================ */
 
// Why one group member is not applied at this scale.
typedef enum rt_shape_status_t
{
  RT_SHAPE_READY = 0, // apply it
  RT_SHAPE_SKIP,      // another scale, outside the layer, nothing to draw: go on with the next one
  RT_SHAPE_ERROR      // out of memory: abort the whole decomposition
} rt_shape_status_t;
 
// A shape of the module's drawn mask, ready to be applied at one wavelet scale.
typedef struct rt_prepared_shape_t
{
  int index;                        // slot in rt_forms[]
  float opacity;                    // the shape's opacity in the group
  dt_iop_retouch_algo_type_t algo;
  float *mask;                      // mask resampled into the layer, READ-ONLY (it may be shared)
  dt_iop_roi_t roi_mask;            // where it lands in the layer
  float dx;                         // offset from the source to the destination
  float dy;
  // The memo entry `mask` belongs to, NULL when it is this shape's own allocation. Either way
  // rt_release_shape() is what hands it back.
  struct dt_pixel_cache_entry_t *mask_entry;
} rt_prepared_shape_t;
 
// Rasterise the shape and resample it into `dst`, which the caller sized from `area` through
// rt_scaled_mask_roi().
static rt_shape_status_t rt_rasterize_scaled_mask(const rt_masks_ctx_t *const ctx, dt_masks_form_t *form,
                                                  const dt_masks_area_t *const area,
                                                  const dt_iop_roi_t *const roi_layer,
                                                  const dt_iop_roi_t *const roi_mask_scaled, float *const dst)
{
  float *mask = NULL;
  dt_masks_area_t rastered = { 0 };
  if(ctx->stats) ctx->stats->masks_rasterised++;
  dt_masks_get_mask(ctx->self, ctx->pipe, ctx->piece, form, &mask, &rastered);
  if(IS_NULL_PTR(mask))
  {
    fprintf(stderr, "rt_process_forms: error retrieving mask\n");
    return RT_SHAPE_SKIP;
  }
 
  /* `dst` was sized from dt_masks_get_area(), which every shape type reaching here implements
   * with the very function its get_mask() uses for its own bounding box. Should the two ever
   * disagree, this buffer is not the one that mask needs: say so and draw nothing rather than
   * write past it. */
  if(rastered.x != area->x || rastered.y != area->y || rastered.width != area->width
     || rastered.height != area->height)
  {
    fprintf(stderr,
            "rt_process_forms: the rasterised area %ix%i+%i+%i disagrees with the announced %ix%i+%i+%i\n",
            rastered.width, rastered.height, rastered.x, rastered.y, area->width, area->height, area->x,
            area->y);
    dt_pixelpipe_cache_free_align(mask);
    return RT_SHAPE_SKIP;
  }
 
  const dt_iop_roi_t roi_mask
      = { .x = area->x, .y = area->y, .width = area->width, .height = area->height, .scale = 1.f };
  rt_fill_scaled_mask(mask, &roi_mask, dst, roi_mask_scaled, roi_layer);
  dt_pixelpipe_cache_free_align(mask);
  return RT_SHAPE_READY;
}
 
/* One memo entry per shape holds the mask AND, in a header ahead of it, the area it was
 * rasterised from. The area is what sizes the lookup, so storing it with the mask is what lets a
 * hit answer without calling dt_masks_get_area() -- which for a brush or a polygon is the whole
 * outline generation, i.e. most of what the memo exists to avoid. The header is a cache line
 * wide so the pixels keep the alignment the resampling loop was written for. */
#define RT_MASK_MEMO_HEADER 64u
 
// Is `area` something the arithmetic below can be trusted with? A memo hit reads it from a line
// resolved by hash alone, so it is checked before it sizes anything.
static gboolean rt_area_is_sane(const dt_masks_area_t *const area)
{
  return area->width > 0 && area->height > 0 && area->width < (1 << 20) && area->height < (1 << 20);
}
 
// Everything but the shape's own area that the memoised mask depends on.
static uint64_t rt_scaled_mask_hash(const uint64_t shape_hash, const dt_iop_roi_t *const roi_layer, const int dx,
                                    const int dy, const dt_iop_retouch_algo_type_t algo)
{
  static const char cache_tag[] = "scaled-mask";
  if(shape_hash == DT_PIXELPIPE_CACHE_HASH_INVALID) return DT_PIXELPIPE_CACHE_HASH_INVALID;
 
  uint64_t hash = dt_hash(shape_hash, cache_tag, sizeof(cache_tag));
  hash = dt_hash(hash, (const char *)roi_layer, sizeof(dt_iop_roi_t));
  hash = dt_hash(hash, (const char *)&dx, sizeof(dx));
  hash = dt_hash(hash, (const char *)&dy, sizeof(dy));
  hash = dt_hash(hash, (const char *)&algo, sizeof(algo));
  return hash;
}
 
// every algorithm needs a mask larger than 2x2, and clone and heal need a source offset
static gboolean rt_shape_has_effect(const rt_prepared_shape_t *const shape, const int dx, const int dy)
{
  return (dx != 0 || dy != 0 || shape->algo == DT_IOP_RETOUCH_BLUR || shape->algo == DT_IOP_RETOUCH_FILL)
         && shape->roi_mask.width > 2 && shape->roi_mask.height > 2;
}
 
// Whether a memo line answered.
typedef enum rt_memo_result_t
{
  RT_MEMO_TAKEN = 0, // `shape` now holds the line, with its reference and its read lock
  RT_MEMO_ABSENT,    // no line to be had: the caller must rasterise
  RT_MEMO_REFUSED    // there is a line and it is not this mask, or rasterising it failed
} rt_memo_result_t;
 
/* Does this line hold the mask this shape wants? Read under the line's read lock, and fills
 * `shape->roi_mask` from the area stored in its header on the way -- which is the point of the
 * header: neither dt_masks_get_area() nor dt_masks_get_mask() runs on a hit. It touches neither
 * the reference nor the lock, so its caller alone decides what is released and what is handed
 * on. TAKEN means the pixels are this shape's. */
static rt_memo_result_t rt_scaled_mask_memo_holds(const void *const data,
                                                  const struct dt_pixel_cache_entry_t *const entry,
                                                  const dt_iop_roi_t *const roi_layer, const int dx, const int dy,
                                                  rt_prepared_shape_t *shape)
{
  dt_masks_area_t area;
  memcpy(&area, data, sizeof(dt_masks_area_t));
  if(!rt_area_is_sane(&area)) return RT_MEMO_ABSENT;
 
  rt_scaled_mask_roi(&area, roi_layer, dx, dy, shape->algo, &shape->roi_mask);
  if(!rt_shape_has_effect(shape, dx, dy)) return RT_MEMO_ABSENT;
 
  /* A hash identifies content, never a size. A line that cannot hold this mask is not this
   * mask: refuse it rather than read past its end. */
  const size_t needed
      = RT_MASK_MEMO_HEADER + (size_t)shape->roi_mask.width * shape->roi_mask.height * sizeof(float);
  if(dt_pixel_cache_entry_get_size(entry) < needed) return RT_MEMO_REFUSED;
 
  return RT_MEMO_TAKEN;
}
 
/* The memoised mask, if there is one.
 *
 * `dt_dev_pixelpipe_cache_ref_entry_by_hash()` takes the reference BEFORE it knows whether the
 * line has a buffer, and answers TRUE for one that has none yet. Every exit from here therefore
 * releases what it took, except the single one that hands it to the shape -- a reference left
 * behind is not a leak that shows up as a crash, it is a line the cache can never evict again. */
static rt_memo_result_t rt_scaled_mask_take_memo(const rt_masks_ctx_t *const ctx, const uint64_t hash,
                                                 const dt_iop_roi_t *const roi_layer, const int dx, const int dy,
                                                 rt_prepared_shape_t *shape)
{
  if(hash == DT_PIXELPIPE_CACHE_HASH_INVALID) return RT_MEMO_ABSENT;
 
  void *data = NULL;
  struct dt_pixel_cache_entry_t *entry = NULL;
  if(!dt_dev_pixelpipe_cache_ref_entry_by_hash(hash, &data, &entry) || IS_NULL_PTR(entry))
    return RT_MEMO_ABSENT;
 
  if(IS_NULL_PTR(data))
  {
    dt_dev_pixelpipe_cache_ref_count_entry(FALSE, entry);
    return RT_MEMO_ABSENT;
  }
 
  dt_dev_pixelpipe_cache_rdlock_entry(TRUE, entry);
  const rt_memo_result_t result = rt_scaled_mask_memo_holds(data, entry, roi_layer, dx, dy, shape);
 
  if(result == RT_MEMO_TAKEN)
  {
    // the reference and the read lock travel with it, until rt_release_shape()
    shape->mask = (float *)((char *)data + RT_MASK_MEMO_HEADER);
    shape->mask_entry = entry;
    if(ctx->stats) ctx->stats->masks_hit++;
    return RT_MEMO_TAKEN;
  }
 
  dt_dev_pixelpipe_cache_rdlock_entry(FALSE, entry);
  dt_dev_pixelpipe_cache_ref_count_entry(FALSE, entry);
  return result;
}
 
/* Rasterise the mask into a memo line and hand that line to the shape. ABSENT when no line can
 * be had, which is not a failure: the caller rasterises into a buffer of its own instead. */
static rt_memo_result_t rt_scaled_mask_publish(const rt_masks_ctx_t *const ctx, dt_masks_form_t *form,
                                               const uint64_t hash, const dt_masks_area_t *const area,
                                               const dt_iop_roi_t *const roi_layer, rt_prepared_shape_t *shape)
{
  if(hash == DT_PIXELPIPE_CACHE_HASH_INVALID) return RT_MEMO_ABSENT;
 
  const size_t bytes = RT_MASK_MEMO_HEADER
                       + (size_t)shape->roi_mask.width * shape->roi_mask.height * sizeof(float);
 
  void *data = NULL;
  struct dt_pixel_cache_entry_t *entry = NULL;
  const int created
      = dt_dev_pixelpipe_cache_get(hash, bytes, "retouch shape mask", ctx->pipe->type, TRUE, &data, &entry);
 
  if(IS_NULL_PTR(data) || IS_NULL_PTR(entry))
  {
    if(!IS_NULL_PTR(entry))
    {
      // Created without a buffer: flagged while still held, so the release removes it rather than
      // leave a line a later get() would allocate and hand back unwritten.
      if(created)
      {
        dt_dev_pixelpipe_cache_flag_auto_destroy(entry);
        dt_dev_pixelpipe_cache_wrlock_entry(FALSE, entry);
      }
      dt_dev_pixelpipe_cache_ref_count_entry(FALSE, entry);
    }
    return RT_MEMO_ABSENT;
  }
 
  /* Not created means another thread published this line between the lookup and here. Its
   * content is this same mask, so take it rather than rasterise a second copy. */
  if(created)
  {
    memcpy(data, area, sizeof(dt_masks_area_t));
    const rt_shape_status_t status = rt_rasterize_scaled_mask(ctx, form, area, roi_layer, &shape->roi_mask,
                                                              (float *)((char *)data + RT_MASK_MEMO_HEADER));
    if(status != RT_SHAPE_READY)
    {
      // Flagged while still held and before the write lock goes, so the release removes it.
      dt_dev_pixelpipe_cache_flag_auto_destroy(entry);
      dt_dev_pixelpipe_cache_wrlock_entry(FALSE, entry);
      dt_dev_pixelpipe_cache_ref_count_entry(FALSE, entry);
      return RT_MEMO_REFUSED;
    }
    dt_dev_pixelpipe_cache_wrlock_entry(FALSE, entry);
  }
 
  /* Read-locked for as long as the caller holds it, so a reader can never overlap the writer
   * that is still filling a line it found already created. */
  dt_dev_pixelpipe_cache_rdlock_entry(TRUE, entry);
  shape->mask = (float *)((char *)data + RT_MASK_MEMO_HEADER);
  shape->mask_entry = entry;
  if(!created && ctx->stats) ctx->stats->masks_hit++; // published by another thread, not by us
  return RT_MEMO_TAKEN;
}
 
// Fill in `shape->roi_mask` and `shape->mask`, rasterising only when the memo has no answer.
// `shape->dx`, `shape->dy` and `shape->algo` must already be set: the resampling depends on them.
static rt_shape_status_t rt_shape_scaled_mask(const rt_masks_ctx_t *const ctx, dt_masks_form_t *form,
                                              const uint64_t shape_hash, const dt_iop_roi_t *const roi_layer,
                                              rt_prepared_shape_t *shape)
{
  const int dx = (int)shape->dx;
  const int dy = (int)shape->dy;
  const uint64_t hash = rt_scaled_mask_hash(shape_hash, roi_layer, dx, dy, shape->algo);
 
  switch(rt_scaled_mask_take_memo(ctx, hash, roi_layer, dx, dy, shape))
  {
    case RT_MEMO_TAKEN: return RT_SHAPE_READY;
    case RT_MEMO_REFUSED: return RT_SHAPE_SKIP;
    case RT_MEMO_ABSENT: break;
  }
 
  dt_masks_area_t area;
  if(!rt_shape_box(ctx, form, shape_hash, RT_BOX_AREA, &area)) return RT_SHAPE_SKIP;
  if(!rt_area_is_sane(&area)) return RT_SHAPE_SKIP;
 
  rt_scaled_mask_roi(&area, roi_layer, dx, dy, shape->algo, &shape->roi_mask);
  if(!rt_shape_has_effect(shape, dx, dy)) return RT_SHAPE_SKIP;
 
  switch(rt_scaled_mask_publish(ctx, form, hash, &area, roi_layer, shape))
  {
    case RT_MEMO_TAKEN: return RT_SHAPE_READY;
    case RT_MEMO_REFUSED: return RT_SHAPE_SKIP;
    case RT_MEMO_ABSENT: break;
  }
 
  // no memo line available: the previous behaviour, one buffer per shape per frame
  const size_t elements = (size_t)shape->roi_mask.width * shape->roi_mask.height;
  float *buffer = dt_pixelpipe_cache_alloc_align_float_cache(elements, 0);
  if(IS_NULL_PTR(buffer))
  {
    fprintf(stderr, "rt_shape_scaled_mask: error allocating memory\n");
    return RT_SHAPE_ERROR;
  }
 
  const rt_shape_status_t status
      = rt_rasterize_scaled_mask(ctx, form, &area, roi_layer, &shape->roi_mask, buffer);
  if(status != RT_SHAPE_READY)
  {
    dt_pixelpipe_cache_free_align(buffer);
    return status;
  }
 
  shape->mask = buffer;
  shape->mask_entry = NULL;
  return RT_SHAPE_READY;
}
 
// Hand back whatever rt_prepare_shape() took. Safe on a shape it returned SKIP or ERROR for.
static void rt_release_shape(rt_prepared_shape_t *shape)
{
  if(!IS_NULL_PTR(shape->mask_entry))
  {
    dt_dev_pixelpipe_cache_rdlock_entry(FALSE, shape->mask_entry);
    dt_dev_pixelpipe_cache_ref_count_entry(FALSE, shape->mask_entry);
    shape->mask_entry = NULL;
    shape->mask = NULL;
    return;
  }
  dt_pixelpipe_cache_free_align(shape->mask);
  shape->mask = NULL;
}
 
// Everything the CPU and OpenCL callbacks need before applying one group member at `scale`: the
// member resolved in the run's snapshot, its offset to the source, and its mask laid out in the
// layer. Kept in one place so the two paths cannot drift; every outcome but RT_SHAPE_READY
// leaves nothing to release.
static rt_shape_status_t rt_prepare_shape(const rt_masks_ctx_t *const ctx, const GList *member,
                                          const int scale, const uint64_t base_hash,
                                          const dt_iop_roi_t *roi_layer, rt_prepared_shape_t *shape)
{
  const dt_iop_retouch_params_t *p = (const dt_iop_retouch_params_t *)ctx->piece->data;
  int formid = 0;
  int index = -1;
  dt_masks_form_t *form = rt_pipe_member_form(ctx->pipe, p, member, &formid, &index);
 
  *shape = (rt_prepared_shape_t){ 0 };
 
  // only process current scale
  if(index >= 0 && p->rt_forms[index].scale != scale) return RT_SHAPE_SKIP;
  if(IS_NULL_PTR(form))
  {
    // an unknown index is expected right after going back in history: the group still lists the
    // shape while rt_forms[] no longer does
    fprintf(stderr, "rt_process_forms: missing form=%i from %s\n", formid, index < 0 ? "array" : "masks");
    return RT_SHAPE_SKIP;
  }
 
  const dt_masks_form_group_t *grpt = (const dt_masks_form_group_t *)member->data;
  shape->index = index;
  shape->opacity = grpt->opacity;
  shape->algo = p->rt_forms[index].algorithm;
 
  // search the delta with the source
  if(shape->algo != DT_IOP_RETOUCH_BLUR && shape->algo != DT_IOP_RETOUCH_FILL
     && !rt_masks_get_delta_to_destination(ctx, roi_layer, form, &shape->dx, &shape->dy,
                                           p->rt_forms[index].distort_mode))
    return RT_SHAPE_SKIP;
 
  /* No separate "is the shape in this layer" test: rt_scaled_mask_roi() intersects the shape's
   * area with the layer, source offset included, and a shape that draws nothing there comes out
   * of it too small to have an effect. That is the same answer dt_masks_form_is_in_roi() gave,
   * reached without rasterising the area a second time. */
  return rt_shape_scaled_mask(ctx, form, rt_shape_geometry_hash(base_hash, form), roi_layer, shape);
}
 
static int rt_process_forms(float *layer, dwt_params_t *const wt_p, const int scale1)
{
  int scale = scale1;
  retouch_user_data_t *usr_d = (retouch_user_data_t *)wt_p->user_data;
  dt_iop_module_t *self = usr_d->self;
  const dt_dev_pixelpipe_t *pipe = usr_d->pipe;
  const dt_dev_pixelpipe_iop_t *piece = usr_d->piece;
 
  // if preview a single scale, just process that scale and original image
  // unless merge is activated
  if(wt_p->merge_from_scale == 0 && wt_p->return_layer > 0 && scale != wt_p->return_layer && scale != 0) return 0;
  // do not process the reconstructed image
  if(scale > wt_p->scales + 1) return 0;
 
  const dt_iop_retouch_params_t *p = (const dt_iop_retouch_params_t *)piece->data;
  dt_iop_roi_t *roi_layer = &usr_d->roi;
  // In single-scale preview (return_layer > 0), the filter above already restricted us to scale 0
  // and the previewed scale itself -- both are exactly what this preview shows, regardless of
  // which scale curr_scale/display_scale currently points at (scale 0's shapes always apply here,
  // even while a *different* scale is being previewed). Requiring scale == display_scale on top,
  // like plain mask display does, would only match when curr_scale happens to equal 0, silently
  // dropping the highlight for a scale-0 shape as soon as the user previews any other scale --
  // even though that same shape's effect keeps being applied and visible in "mask display" alone.
  const int mask_display
      = usr_d->mask_display && (wt_p->return_layer > 0 || scale == usr_d->display_scale);
 
  // when the requested scales is grather than max scales the residual image index will be different from the one
  // defined by the user,
  // so we need to adjust it here, otherwise we will be using the shapes from a scale on the residual image
  if(wt_p->scales < p->num_scales && wt_p->return_layer == 0 && scale == wt_p->scales + 1)
  {
    scale = p->num_scales + 1;
  }
 
  if(usr_d->suppress_mask) return 0;
 
  const rt_masks_ctx_t ctx = { self, pipe, piece, usr_d->stats };
  const uint64_t base_hash = rt_geometry_base_hash(pipe, piece);
 
  // Iterate through all forms, resolved in the run's snapshot (see dt_masks_get_from_id_in_pipe()).
  for(const GList *forms = rt_pipe_group_members(pipe, piece); forms; forms = g_list_next(forms))
  {
    rt_prepared_shape_t shape;
    const rt_shape_status_t status = rt_prepare_shape(&ctx, forms, scale, base_hash, roi_layer, &shape);
    if(status == RT_SHAPE_ERROR) return 1;
    if(status != RT_SHAPE_READY) continue;
 
    const int index = shape.index;
    const float form_opacity = shape.opacity;
    const dt_iop_retouch_algo_type_t algo = shape.algo;
    float *mask_scaled = shape.mask;
    dt_iop_roi_t roi_mask_scaled = shape.roi_mask;
    const int dx = (int)shape.dx;
    const int dy = (int)shape.dy;
 
    const double algo_start = usr_d->stats ? dt_get_wtime() : 0.0;
 
    if(algo == DT_IOP_RETOUCH_CLONE)
    {
      if(_retouch_clone(layer, roi_layer, mask_scaled, &roi_mask_scaled, dx, dy, form_opacity) != 0)
      {
        rt_release_shape(&shape);
        return 1;
      }
    }
    else if(algo == DT_IOP_RETOUCH_HEAL)
    {
      if(_retouch_heal(layer, roi_layer, mask_scaled, &roi_mask_scaled, dx, dy, form_opacity, p->max_heal_iter,
                       rt_heal_domain(p, scale1, wt_p->scales)) != 0)
      {
        rt_release_shape(&shape);
        return 1;
      }
    }
    else if(algo == DT_IOP_RETOUCH_BLUR)
    {
      if(_retouch_blur(self, pipe, layer, roi_layer, mask_scaled, &roi_mask_scaled, form_opacity,
                       p->rt_forms[index].blur_type, p->rt_forms[index].blur_radius, wt_p->use_sse) != 0)
      {
        rt_release_shape(&shape);
        return 1;
      }
    }
    else if(algo == DT_IOP_RETOUCH_FILL)
    {
      // add a brightness to the color so it can be fine-adjusted by the user
      dt_aligned_pixel_t fill_color;
 
      if(p->rt_forms[index].fill_mode == DT_IOP_RETOUCH_FILL_ERASE)
      {
        fill_color[0] = fill_color[1] = fill_color[2] = p->rt_forms[index].fill_brightness;
      }
      else
      {
        fill_color[0] = p->rt_forms[index].fill_color[0] + p->rt_forms[index].fill_brightness;
        fill_color[1] = p->rt_forms[index].fill_color[1] + p->rt_forms[index].fill_brightness;
        fill_color[2] = p->rt_forms[index].fill_color[2] + p->rt_forms[index].fill_brightness;
      }
      fill_color[3] = 0.0f;
 
      _retouch_fill(layer, roi_layer, mask_scaled, &roi_mask_scaled, form_opacity, fill_color);
    }
    else
      fprintf(stderr, "rt_process_forms: unknown algorithm %i\n", algo);
 
    if(usr_d->stats)
    {
      usr_d->stats->shapes_applied++;
      usr_d->stats->algo_seconds += dt_get_wtime() - algo_start;
    }
 
    if(mask_display)
      rt_copy_mask_to_alpha(layer, roi_layer, wt_p->ch, mask_scaled, &roi_mask_scaled, form_opacity);
 
    rt_release_shape(&shape);
  }
 
  return 0;
}
 
/* One line per render, after every wavelet scale has been through the callback. Together with
 * the modify_roi_in() line it accounts for the whole of what this module costs a frame, which is
 * the question a shape drag asks. */
static void rt_report_render(const dt_dev_pixelpipe_t *pipe, const dt_iop_roi_t *const roi,
                             const rt_memo_stats_t *const stats, const double start, const char *const path)
{
  dt_print(DT_DEBUG_PERF,
           "[retouch] %-8s process %s %dx%d: %d shape(s), masks %d (%d memo / %d rasterised),"
           " boxes %d (%d memo / %d rasterised), algorithms %.3f s, total %.3f s\n",
           dt_pixelpipe_name(pipe->type), path, roi->width, roi->height, stats->shapes_applied,
           stats->masks_hit + stats->masks_rasterised, stats->masks_hit, stats->masks_rasterised,
           stats->boxes_hit + stats->boxes_computed, stats->boxes_hit, stats->boxes_computed,
           stats->algo_seconds, dt_get_wtime() - start);
}
 
__DT_CLONE_TARGETS__
static int process_internal(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe,
                            const dt_dev_pixelpipe_iop_t *piece, const void *const ivoid,
                            void *const ovoid, const dt_iop_roi_t *const roi_in,
                            const dt_iop_roi_t *const roi_out, const int use_sse)
{
 
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)piece->data;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  float *in_retouch = NULL;
  int err = 0;
 
  dt_iop_roi_t roi_retouch = *roi_in;
  dt_iop_roi_t *roi_rt = &roi_retouch;
 
  retouch_user_data_t usr_data = { 0 };
  dwt_params_t *dwt_p = NULL;
  rt_memo_stats_t counters = { 0 };
  const gboolean counting = rt_perf_enabled();
  const double render_start = counting ? dt_get_wtime() : 0.0;
 
  const int gui_active = (self->dev) ? (self == self->dev->gui_module) : 0;
  const int display_wavelet_scale = (g && gui_active) ? g->display_wavelet_scale : 0;
 
  // we will do all the clone, heal, etc on the input image,
  // this way the source for one algorithm can be the destination from a previous one
  in_retouch = dt_pixelpipe_cache_alloc_align_float_cache((size_t)4 * roi_rt->width * roi_rt->height, 0);
  if(IS_NULL_PTR(in_retouch))
  {
    err = 1;
    goto cleanup;
  }
 
  dt_iop_image_copy_by_size(in_retouch, ivoid, roi_rt->width, roi_rt->height, 4);
 
  // user data passed from the decompose routine to the one that process each scale
  usr_data.self = self;
  usr_data.pipe = pipe;
  usr_data.piece = piece;
  usr_data.roi = *roi_rt;
  usr_data.mask_display = 0;
  usr_data.suppress_mask = (g && g->suppress_mask && self->dev->gui_attached && (self == self->dev->gui_module)
                            && (pipe == self->dev->pipe));
  usr_data.display_scale = p->curr_scale;
  usr_data.stats = counting ? &counters : NULL;
 
  // init the decompose routine
  dwt_p = dt_dwt_init(in_retouch, roi_rt->width, roi_rt->height, 4, p->num_scales,
                      (!display_wavelet_scale || pipe->type != DT_DEV_PIXELPIPE_FULL) ? 0 : p->curr_scale,
                      p->merge_from_scale, &usr_data,
                      roi_in->scale, use_sse);
  if(IS_NULL_PTR(dwt_p))
  {
    err = 1;
    goto cleanup;
  }
 
  // check if this module should expose mask.
  if(pipe->type == DT_DEV_PIXELPIPE_FULL && !IS_NULL_PTR(g)
     && (g->mask_display || display_wavelet_scale) && self->dev->gui_attached
     && (self == self->dev->gui_module) && (pipe == self->dev->pipe))
  {
    for(size_t j = 0; j < (size_t)roi_rt->width * roi_rt->height * 4; j += 4) in_retouch[j + 3] = 0.f;
 
    ((dt_dev_pixelpipe_t *)pipe)->mask_display = g->mask_display ? DT_DEV_PIXELPIPE_DISPLAY_MASK : DT_DEV_PIXELPIPE_DISPLAY_PASSTHRU;
    ((dt_dev_pixelpipe_t *)pipe)->bypass_blendif = 1;
    usr_data.mask_display = 1;
  }
 
  if(pipe->type == DT_DEV_PIXELPIPE_FULL)
  {
    // check if the image support this number of scales
    if(gui_active)
    {
      const int max_scales = dwt_get_max_scale(dwt_p);
      if(dwt_p->scales > max_scales)
      {
        dt_control_log(_("max scale is %i for this image size"), max_scales);
      }
    }
    // get first scale visible at this zoom level
    if(g) g->first_scale_visible = dt_dwt_first_scale_visible(dwt_p);
  }
 
  // decompose it
  if(dwt_decompose(dwt_p, rt_process_forms) != 0)
  {
    err = 1;
    goto cleanup;
  }
 
  if(counting) rt_report_render(pipe, roi_rt, &counters, render_start, "on CPU");
 
  dt_aligned_pixel_t levels = { p->preview_levels[0], p->preview_levels[1], p->preview_levels[2] };
 
  // process auto levels
  if(!IS_NULL_PTR(g) && pipe->type == DT_DEV_PIXELPIPE_FULL)
  {
    dt_iop_gui_enter_critical_section(self);
    if(g->preview_auto_levels == 1 && !dt_gui_widgets_suppressed())
    {
      g->preview_auto_levels = -1;
 
      dt_iop_gui_leave_critical_section(self);
 
      levels[0] = levels[1] = levels[2] = 0;
      rt_process_stats(self, pipe, in_retouch, roi_rt->width, roi_rt->height, 4, levels);
      rt_clamp_minmax(levels, levels);
 
      for(int i = 0; i < 3; i++) g->preview_levels[i] = levels[i];
 
      dt_iop_gui_enter_critical_section(self);
      g->preview_auto_levels = 2;
    }
    dt_iop_gui_leave_critical_section(self);
  }
 
  // if user wants to preview a detail scale adjust levels
  if(dwt_p->return_layer > 0 && dwt_p->return_layer < dwt_p->scales + 1)
  {
    rt_adjust_levels(self, pipe, in_retouch, roi_rt->width, roi_rt->height, 4, levels);
  }
 
  // copy alpha channel if needed
  if((pipe->mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK) && !IS_NULL_PTR(g) && !g->mask_display)
  {
    dt_iop_alpha_copy(ivoid, in_retouch, roi_rt->width, roi_rt->height);
  }
 
  // return final image
  rt_copy_in_to_out(in_retouch, roi_rt, ovoid, roi_out, 4, 0, 0);
 
cleanup:
  dt_pixelpipe_cache_free_align(in_retouch);
  if(dwt_p) dt_dwt_free(dwt_p);
  return err;
}
 
int process(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece, const void *const ivoid,
             void *const ovoid)
{
  const dt_iop_roi_t *const roi_in = &piece->roi_in;
  const dt_iop_roi_t *const roi_out = &piece->roi_out;
  return process_internal(self, pipe, piece, ivoid, ovoid, roi_in, roi_out, 0);
}
 
void distort_mask(struct dt_iop_module_t *self, const struct dt_dev_pixelpipe_t *pipe, struct dt_dev_pixelpipe_iop_t *piece,
                  const float *const in, float *const out, const dt_iop_roi_t *const roi_in,
                  const dt_iop_roi_t *const roi_out)
{
  (void)pipe;
  rt_copy_in_to_out(in, roi_in, out, roi_out, 1, 0, 0);
}
 
#ifdef HAVE_OPENCL
 
cl_int rt_process_stats_cl(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe,
                           const int devid, cl_mem dev_img, const int width, const int height,
                           float levels[3])
{
  cl_int err = CL_SUCCESS;
 
  const int ch = 4;
 
  float *src_buffer = NULL;
 
  src_buffer = dt_pixelpipe_cache_alloc_align_float_cache((size_t)ch * width * height, 0);
  if(IS_NULL_PTR(src_buffer))
  {
    fprintf(stderr, "dt_heal_cl: error allocating memory for healing\n");
    err = DT_OPENCL_SYSMEM_ALLOCATION;
    goto cleanup;
  }
 
  err = dt_opencl_read_buffer_from_device(devid, (void *)src_buffer, dev_img, 0,
                                          (size_t)width * height * ch * sizeof(float), CL_TRUE);
  if(err != CL_SUCCESS)
  {
    goto cleanup;
  }
 
  // just call the CPU version for now
  rt_process_stats(self, pipe, src_buffer, width, height, ch, levels);
 
  err = dt_opencl_write_buffer_to_device(devid, src_buffer, dev_img, 0, sizeof(float) * ch * width * height, CL_TRUE);
  if(err != CL_SUCCESS)
  {
    goto cleanup;
  }
 
cleanup:
  dt_pixelpipe_cache_free_align(src_buffer);
 
  return err;
}
 
cl_int rt_adjust_levels_cl(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe,
                           const int devid, cl_mem dev_img, const int width, const int height,
                           const float levels[3])
{
  cl_int err = CL_SUCCESS;
 
  const int ch = 4;
 
  float *src_buffer = NULL;
 
  src_buffer = dt_pixelpipe_cache_alloc_align_float_cache((size_t)ch * width * height, 0);
  if(IS_NULL_PTR(src_buffer))
  {
    fprintf(stderr, "dt_heal_cl: error allocating memory for healing\n");
    err = DT_OPENCL_SYSMEM_ALLOCATION;
    goto cleanup;
  }
 
  err = dt_opencl_read_buffer_from_device(devid, (void *)src_buffer, dev_img, 0,
                                          (size_t)width * height * ch * sizeof(float), CL_TRUE);
  if(err != CL_SUCCESS)
  {
    goto cleanup;
  }
 
  // just call the CPU version for now
  rt_adjust_levels(self, pipe, src_buffer, width, height, ch, levels);
 
  err = dt_opencl_write_buffer_to_device(devid, src_buffer, dev_img, 0, sizeof(float) * ch * width * height, CL_TRUE);
  if(err != CL_SUCCESS)
  {
    goto cleanup;
  }
 
cleanup:
  dt_pixelpipe_cache_free_align(src_buffer);
 
  return err;
}
 
static cl_int rt_copy_in_to_out_cl(const int devid, cl_mem dev_in, const struct dt_iop_roi_t *const roi_in,
                                   cl_mem dev_out, const struct dt_iop_roi_t *const roi_out, const int dx,
                                   const int dy, const int kernel)
{
  cl_int err = CL_SUCCESS;
 
  const int xoffs = roi_out->x - roi_in->x - dx;
  const int yoffs = roi_out->y - roi_in->y - dy;
 
  cl_mem dev_roi_in = NULL;
  cl_mem dev_roi_out = NULL;
 
  const size_t sizes[]
      = { ROUNDUPDWD(MIN(roi_out->width, roi_in->width), devid), ROUNDUPDHT(MIN(roi_out->height, roi_in->height), devid), 1 };
 
  dev_roi_in = dt_opencl_copy_host_to_device_constant(devid, sizeof(dt_iop_roi_t), (void *)roi_in);
  dev_roi_out = dt_opencl_copy_host_to_device_constant(devid, sizeof(dt_iop_roi_t), (void *)roi_out);
  if(IS_NULL_PTR(dev_roi_in) || IS_NULL_PTR(dev_roi_out))
  {
    fprintf(stderr, "rt_copy_in_to_out_cl error 1\n");
    err = CL_MEM_OBJECT_ALLOCATION_FAILURE;
    goto cleanup;
  }
 
  dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_in);
  dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&dev_roi_in);
  dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(cl_mem), (void *)&dev_out);
  dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(cl_mem), (void *)&dev_roi_out);
  dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(int), (void *)&xoffs);
  dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(int), (void *)&yoffs);
  err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
  if(err != CL_SUCCESS)
  {
    fprintf(stderr, "rt_copy_in_to_out_cl error 2\n");
    goto cleanup;
  }
 
cleanup:
  dt_opencl_release_mem_object(dev_roi_in);
  dt_opencl_release_mem_object(dev_roi_out);
 
  return err;
}
 
// Upload a prepared shape's mask to the device. The host copy stays valid -- it belongs to the
// shape, and _retouch_heal_cl() still needs it, heal itself running on the CPU.
static cl_int rt_upload_scaled_mask_cl(const int devid, const rt_prepared_shape_t *const shape,
                                       cl_mem *p_dev_mask_scaled)
{
  const size_t bytes = sizeof(float) * shape->roi_mask.width * shape->roi_mask.height;
 
  const cl_mem dev_mask_scaled = dt_opencl_alloc_device_buffer(devid, bytes);
  if(IS_NULL_PTR(dev_mask_scaled))
  {
    fprintf(stderr, "rt_upload_scaled_mask_cl: error allocating the device buffer\n");
    return CL_MEM_OBJECT_ALLOCATION_FAILURE;
  }
 
  const cl_int err = dt_opencl_write_buffer_to_device(devid, shape->mask, dev_mask_scaled, 0, bytes, CL_TRUE);
  if(err != CL_SUCCESS)
  {
    fprintf(stderr, "rt_upload_scaled_mask_cl: error writing the mask to the device\n");
    dt_opencl_release_mem_object(dev_mask_scaled);
    return err;
  }
 
  *p_dev_mask_scaled = dev_mask_scaled;
  return CL_SUCCESS;
}
 
static cl_int rt_copy_image_masked_cl(const int devid, cl_mem dev_src, cl_mem dev_dest,
                                      dt_iop_roi_t *const roi_dest, cl_mem dev_mask_scaled,
                                      dt_iop_roi_t *const roi_mask_scaled, const float opacity, const int kernel)
{
  cl_int err = CL_SUCCESS;
 
  const size_t sizes[] = { ROUNDUPDWD(roi_mask_scaled->width, devid), ROUNDUPDHT(roi_mask_scaled->height, devid), 1 };
 
  const cl_mem dev_roi_dest =
    dt_opencl_copy_host_to_device_constant(devid, sizeof(dt_iop_roi_t), (void *)roi_dest);
 
  const cl_mem dev_roi_mask_scaled
      = dt_opencl_copy_host_to_device_constant(devid, sizeof(dt_iop_roi_t), (void *)roi_mask_scaled);
 
  if(IS_NULL_PTR(dev_roi_dest) || IS_NULL_PTR(dev_roi_mask_scaled))
  {
    err = CL_MEM_OBJECT_ALLOCATION_FAILURE;
    goto cleanup;
  }
 
  dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_src);
  dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&dev_dest);
  dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(cl_mem), (void *)&dev_roi_dest);
  dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(cl_mem), (void *)&dev_mask_scaled);
  dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(cl_mem), (void *)&dev_roi_mask_scaled);
  dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(float), (void *)&opacity);
  err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
  if(err != CL_SUCCESS) goto cleanup;
 
cleanup:
  dt_opencl_release_mem_object(dev_roi_dest);
  dt_opencl_release_mem_object(dev_roi_mask_scaled);
 
  return err;
}
 
static cl_int rt_copy_mask_to_alpha_cl(const int devid, cl_mem dev_layer, dt_iop_roi_t *const roi_layer,
                                       cl_mem dev_mask_scaled, dt_iop_roi_t *const roi_mask_scaled,
                                       const float opacity, dt_iop_retouch_global_data_t *gd)
{
  cl_int err = CL_SUCCESS;
 
  // fill it
  const int kernel = gd->kernel_retouch_copy_mask_to_alpha;
  const size_t sizes[] = { ROUNDUPDWD(roi_mask_scaled->width, devid), ROUNDUPDHT(roi_mask_scaled->height, devid), 1 };
 
  const cl_mem  dev_roi_layer = dt_opencl_copy_host_to_device_constant(devid, sizeof(dt_iop_roi_t), (void *)roi_layer);
  const cl_mem dev_roi_mask_scaled
      = dt_opencl_copy_host_to_device_constant(devid, sizeof(dt_iop_roi_t), (void *)roi_mask_scaled);
  if(IS_NULL_PTR(dev_roi_layer) || IS_NULL_PTR(dev_roi_mask_scaled))
  {
    err = CL_MEM_OBJECT_ALLOCATION_FAILURE;
    goto cleanup;
  }
 
  dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_layer);
  dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&dev_roi_layer);
  dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(cl_mem), (void *)&dev_mask_scaled);
  dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(cl_mem), (void *)&dev_roi_mask_scaled);
  dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(float), (void *)&opacity);
  err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
  if(err != CL_SUCCESS) goto cleanup;
 
 
cleanup:
  dt_opencl_release_mem_object(dev_roi_layer);
  dt_opencl_release_mem_object(dev_roi_mask_scaled);
 
  return err;
}
 
static cl_int _retouch_clone_cl(const int devid, cl_mem dev_layer, dt_iop_roi_t *const roi_layer,
                                cl_mem dev_mask_scaled, dt_iop_roi_t *const roi_mask_scaled, const int dx,
                                const int dy, const float opacity, dt_iop_retouch_global_data_t *gd)
{
  cl_int err = CL_SUCCESS;
 
  const int ch = 4;
 
  // alloc source temp image to avoid issues when areas self-intersects
  const cl_mem dev_src = dt_opencl_alloc_device_buffer(devid,
                                          sizeof(float) * ch * roi_mask_scaled->width * roi_mask_scaled->height);
  if(IS_NULL_PTR(dev_src))
  {
    fprintf(stderr, "retouch_clone_cl error 2\n");
    err = CL_MEM_OBJECT_ALLOCATION_FAILURE;
    goto cleanup;
  }
 
  // copy source image to tmp
  err = rt_copy_in_to_out_cl(devid, dev_layer, roi_layer, dev_src, roi_mask_scaled, dx, dy,
                             gd->kernel_retouch_copy_buffer_to_buffer);
  if(err != CL_SUCCESS)
  {
    fprintf(stderr, "retouch_clone_cl error 4\n");
    goto cleanup;
  }
 
  // clone it
  err = rt_copy_image_masked_cl(devid, dev_src, dev_layer, roi_layer, dev_mask_scaled, roi_mask_scaled, opacity,
                                gd->kernel_retouch_copy_buffer_to_buffer_masked);
  if(err != CL_SUCCESS)
  {
    fprintf(stderr, "retouch_clone_cl error 5\n");
    goto cleanup;
  }
 
cleanup:
  dt_opencl_release_mem_object(dev_src);
 
  return err;
}
 
static cl_int _retouch_fill_cl(const int devid, cl_mem dev_layer, dt_iop_roi_t *const roi_layer,
                               cl_mem dev_mask_scaled, dt_iop_roi_t *const roi_mask_scaled, const float opacity,
                               float *color, dt_iop_retouch_global_data_t *gd)
{
  cl_int err = CL_SUCCESS;
 
  // fill it
  const int kernel = gd->kernel_retouch_fill;
  const size_t sizes[] = { ROUNDUPDWD(roi_mask_scaled->width, devid), ROUNDUPDHT(roi_mask_scaled->height, devid), 1 };
 
  const cl_mem dev_roi_layer = dt_opencl_copy_host_to_device_constant(devid, sizeof(dt_iop_roi_t), (void *)roi_layer);
  const cl_mem dev_roi_mask_scaled
      = dt_opencl_copy_host_to_device_constant(devid, sizeof(dt_iop_roi_t), (void *)roi_mask_scaled);
  if(IS_NULL_PTR(dev_roi_layer) || IS_NULL_PTR(dev_roi_mask_scaled))
  {
    err = CL_MEM_OBJECT_ALLOCATION_FAILURE;
    goto cleanup;
  }
 
  dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_layer);
  dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&dev_roi_layer);
  dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(cl_mem), (void *)&dev_mask_scaled);
  dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(cl_mem), (void *)&dev_roi_mask_scaled);
  dt_opencl_set_kernel_arg(devid, kernel, 4, sizeof(float), (void *)&opacity);
  dt_opencl_set_kernel_arg(devid, kernel, 5, sizeof(float), (void *)&(color[0]));
  dt_opencl_set_kernel_arg(devid, kernel, 6, sizeof(float), (void *)&(color[1]));
  dt_opencl_set_kernel_arg(devid, kernel, 7, sizeof(float), (void *)&(color[2]));
  err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
  if(err != CL_SUCCESS) goto cleanup;
 
 
cleanup:
  dt_opencl_release_mem_object(dev_roi_layer);
  dt_opencl_release_mem_object(dev_roi_mask_scaled);
 
  return err;
}
 
static cl_int _retouch_blur_cl(const int devid, cl_mem dev_layer, dt_iop_roi_t *const roi_layer,
                               cl_mem dev_mask_scaled, dt_iop_roi_t *const roi_mask_scaled, const float opacity,
                               const int blur_type, const float blur_radius, dt_iop_retouch_global_data_t *gd)
{
  cl_int err = CL_SUCCESS;
 
  if(fabsf(blur_radius) <= 0.1f) return err;
 
  const float sigma = blur_radius * roi_layer->scale;
  const int ch = 4;
 
  const cl_mem dev_dest =
    dt_opencl_alloc_device(devid, roi_mask_scaled->width, roi_mask_scaled->height, sizeof(float) * ch);
  if(IS_NULL_PTR(dev_dest))
  {
    fprintf(stderr, "retouch_blur_cl error 2\n");
    err = CL_MEM_OBJECT_ALLOCATION_FAILURE;
    goto cleanup;
  }
 
  if(blur_type == DT_IOP_RETOUCH_BLUR_BILATERAL)
  {
    const int kernel = gd->kernel_retouch_image_rgb2lab;
    size_t sizes[] = { ROUNDUPDWD(roi_layer->width, devid), ROUNDUPDHT(roi_layer->height, devid), 1 };
 
    dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_layer);
    dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(int), (void *)&(roi_layer->width));
    dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&(roi_layer->height));
    err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
    if(err != CL_SUCCESS) goto cleanup;
  }
 
  err = rt_copy_in_to_out_cl(devid, dev_layer, roi_layer, dev_dest, roi_mask_scaled, 0, 0,
                             gd->kernel_retouch_copy_buffer_to_image);
  if(err != CL_SUCCESS)
  {
    fprintf(stderr, "retouch_blur_cl error 4\n");
    goto cleanup;
  }
 
  if(blur_type == DT_IOP_RETOUCH_BLUR_GAUSSIAN && fabsf(blur_radius) > 0.1f)
  {
    float Labmax[] = { INFINITY, INFINITY, INFINITY, INFINITY };
    float Labmin[] = { -INFINITY, -INFINITY, -INFINITY, -INFINITY };
 
    dt_gaussian_cl_t *g = dt_gaussian_init_cl(devid, roi_mask_scaled->width, roi_mask_scaled->height, ch, Labmax,
                                              Labmin, sigma, DT_IOP_GAUSSIAN_ZERO);
    if(g)
    {
      err = dt_gaussian_blur_cl(g, dev_dest, dev_dest);
      dt_gaussian_free_cl(g);
      if(err != CL_SUCCESS) goto cleanup;
    }
  }
  else if(blur_type == DT_IOP_RETOUCH_BLUR_BILATERAL && fabsf(blur_radius) > 0.1f)
  {
    const float sigma_r = 100.0f; // does not depend on scale
    const float sigma_s = sigma;
    const float detail = -1.0f; // we want the bilateral base layer
 
    dt_bilateral_cl_t *b
        = dt_bilateral_init_cl(devid, roi_mask_scaled->width, roi_mask_scaled->height, sigma_s, sigma_r);
    if(b)
    {
      err = dt_bilateral_splat_cl(b, dev_dest);
      if(err == CL_SUCCESS) err = dt_bilateral_blur_cl(b);
      if(err == CL_SUCCESS) err = dt_bilateral_slice_cl(b, dev_dest, dev_dest, detail);
 
      dt_bilateral_free_cl(b);
    }
  }
 
  // copy blurred (temp) image to destination image
  err = rt_copy_image_masked_cl(devid, dev_dest, dev_layer, roi_layer, dev_mask_scaled, roi_mask_scaled, opacity,
                                gd->kernel_retouch_copy_image_to_buffer_masked);
  if(err != CL_SUCCESS)
  {
    fprintf(stderr, "retouch_blur_cl error 5\n");
    goto cleanup;
  }
 
  if(blur_type == DT_IOP_RETOUCH_BLUR_BILATERAL)
  {
    const int kernel = gd->kernel_retouch_image_lab2rgb;
    const size_t sizes[] = { ROUNDUPDWD(roi_layer->width, devid), ROUNDUPDHT(roi_layer->height, devid), 1 };
 
    dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_layer);
    dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(int), (void *)&(roi_layer->width));
    dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&(roi_layer->height));
    err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
    if(err != CL_SUCCESS) goto cleanup;
  }
 
cleanup:
  dt_opencl_release_mem_object(dev_dest);
 
  return err;
}
 
static cl_int _retouch_heal_cl(const int devid, cl_mem dev_layer, dt_iop_roi_t *const roi_layer, float *mask_scaled,
                               cl_mem dev_mask_scaled, dt_iop_roi_t *const roi_mask_scaled, const int dx,
                               const int dy, const float opacity, const dt_iop_retouch_global_data_t *const gd,
                               const int max_iter, const dt_heal_domain_t domain)
{
  cl_int err = CL_SUCCESS;
 
  const int ch = 4;
 
  cl_mem dev_dest = NULL;
  cl_mem dev_src = dt_opencl_alloc_device_buffer(devid,
                                          sizeof(float) * ch * roi_mask_scaled->width * roi_mask_scaled->height);
  if(IS_NULL_PTR(dev_src))
  {
    fprintf(stderr, "retouch_heal_cl: error allocating memory for healing\n");
    err = CL_MEM_OBJECT_ALLOCATION_FAILURE;
    goto cleanup;
  }
 
  dev_dest = dt_opencl_alloc_device_buffer(devid,
                                           sizeof(float) * ch * roi_mask_scaled->width * roi_mask_scaled->height);
  if(IS_NULL_PTR(dev_dest))
  {
    fprintf(stderr, "retouch_heal_cl: error allocating memory for healing\n");
    err = CL_MEM_OBJECT_ALLOCATION_FAILURE;
    goto cleanup;
  }
 
  err = rt_copy_in_to_out_cl(devid, dev_layer, roi_layer, dev_src, roi_mask_scaled, dx, dy,
                             gd->kernel_retouch_copy_buffer_to_buffer);
  if(err != CL_SUCCESS)
  {
    fprintf(stderr, "retouch_heal_cl error 4\n");
    goto cleanup;
  }
 
  err = rt_copy_in_to_out_cl(devid, dev_layer, roi_layer, dev_dest, roi_mask_scaled, 0, 0,
                             gd->kernel_retouch_copy_buffer_to_buffer);
  if(err != CL_SUCCESS)
  {
    fprintf(stderr, "retouch_heal_cl error 4\n");
    goto cleanup;
  }
 
  // heal it
  heal_params_cl_t *hp = dt_heal_init_cl(devid);
  if(hp)
  {
    err = dt_heal_cl(hp, dev_src, dev_dest, mask_scaled, roi_mask_scaled->width, roi_mask_scaled->height,
                     (dt_heal_solver_t){ .max_iter = max_iter, .domain = domain });
    dt_heal_free_cl(hp);
 
    dt_opencl_release_mem_object(dev_src);
    dev_src = NULL;
 
    if(err != CL_SUCCESS) goto cleanup;
  }
 
  // copy healed (temp) image to destination image
  err = rt_copy_image_masked_cl(devid, dev_dest, dev_layer, roi_layer, dev_mask_scaled, roi_mask_scaled, opacity,
                                gd->kernel_retouch_copy_buffer_to_buffer_masked);
  if(err != CL_SUCCESS)
  {
    fprintf(stderr, "retouch_heal_cl error 6\n");
    goto cleanup;
  }
 
cleanup:
  dt_opencl_release_mem_object(dev_src);
  dt_opencl_release_mem_object(dev_dest);
 
  return err;
}
 
static cl_int rt_process_forms_cl(cl_mem dev_layer, dwt_params_cl_t *const wt_p, const int scale1)
{
  cl_int err = CL_SUCCESS;
 
  int scale = scale1;
  retouch_user_data_t *usr_d = (retouch_user_data_t *)wt_p->user_data;
  dt_iop_module_t *self = usr_d->self;
  const dt_dev_pixelpipe_t *pipe = usr_d->pipe;
  const dt_dev_pixelpipe_iop_t *piece = usr_d->piece;
 
  // if preview a single scale, just process that scale and original image
  // unless merge is activated
  if(wt_p->merge_from_scale == 0 && wt_p->return_layer > 0 && scale != wt_p->return_layer && scale != 0)
    return err;
  // do not process the reconstructed image
  if(scale > wt_p->scales + 1) return err;
 
  const dt_iop_retouch_params_t *p = (const dt_iop_retouch_params_t *)piece->data;
  dt_iop_retouch_global_data_t *gd = (dt_iop_retouch_global_data_t *)self->global_data;
  const int devid = pipe->devid;
  dt_iop_roi_t *roi_layer = &usr_d->roi;
  // See the CPU rt_process_forms() for why return_layer > 0 bypasses the display_scale match.
  const int mask_display
      = usr_d->mask_display && (wt_p->return_layer > 0 || scale == usr_d->display_scale);
 
  // when the requested scales is grather than max scales the residual image index will be different from the one
  // defined by the user,
  // so we need to adjust it here, otherwise we will be using the shapes from a scale on the residual image
  if(wt_p->scales < p->num_scales && wt_p->return_layer == 0 && scale == wt_p->scales + 1)
  {
    scale = p->num_scales + 1;
  }
 
  const rt_masks_ctx_t ctx = { self, pipe, piece, usr_d->stats };
  const uint64_t base_hash = rt_geometry_base_hash(pipe, piece);
 
  // Iterate through all forms, resolved in the same snapshot as the CPU rt_process_forms().
  if(!usr_d->suppress_mask)
  {
    for(const GList *forms = rt_pipe_group_members(pipe, piece); forms && err == CL_SUCCESS;
        forms = g_list_next(forms))
    {
      rt_prepared_shape_t shape;
      const rt_shape_status_t status
          = rt_prepare_shape(&ctx, forms, scale, base_hash, roi_layer, &shape);
      if(status == RT_SHAPE_ERROR)
      {
        err = DT_OPENCL_SYSMEM_ALLOCATION;
        break;
      }
      if(status != RT_SHAPE_READY) continue;
 
      const int index = shape.index;
      const float form_opacity = shape.opacity;
      const dt_iop_retouch_algo_type_t algo = shape.algo;
      float *mask_scaled = shape.mask;
      dt_iop_roi_t roi_mask_scaled = shape.roi_mask;
      const int dx = (int)shape.dx;
      const int dy = (int)shape.dy;
 
      cl_mem dev_mask_scaled = NULL;
      err = rt_upload_scaled_mask_cl(devid, &shape, &dev_mask_scaled);
 
      /* On the device this measures the upload and the enqueue, not the kernels -- except for
       * heal, which reads back, solves on the CPU and writes again, and is therefore genuinely
       * synchronous here. */
      const double algo_start = usr_d->stats ? dt_get_wtime() : 0.0;
 
      if(err == CL_SUCCESS)
      {
        if(algo == DT_IOP_RETOUCH_CLONE)
        {
          err = _retouch_clone_cl(devid, dev_layer, roi_layer, dev_mask_scaled, &roi_mask_scaled, dx, dy,
                                  form_opacity, gd);
        }
        else if(algo == DT_IOP_RETOUCH_HEAL)
        {
          err = _retouch_heal_cl(devid, dev_layer, roi_layer, mask_scaled, dev_mask_scaled, &roi_mask_scaled, dx,
                                  dy, form_opacity, gd, p->max_heal_iter, rt_heal_domain(p, scale1, wt_p->scales));
        }
        else if(algo == DT_IOP_RETOUCH_BLUR)
        {
          err = _retouch_blur_cl(devid, dev_layer, roi_layer, dev_mask_scaled, &roi_mask_scaled, form_opacity,
                                  p->rt_forms[index].blur_type, p->rt_forms[index].blur_radius, gd);
        }
        else if(algo == DT_IOP_RETOUCH_FILL)
        {
          // add a brightness to the color so it can be fine-adjusted by the user
          dt_aligned_pixel_t fill_color;
 
          if(p->rt_forms[index].fill_mode == DT_IOP_RETOUCH_FILL_ERASE)
          {
            fill_color[0] = fill_color[1] = fill_color[2] = p->rt_forms[index].fill_brightness;
          }
          else
          {
            fill_color[0] = p->rt_forms[index].fill_color[0] + p->rt_forms[index].fill_brightness;
            fill_color[1] = p->rt_forms[index].fill_color[1] + p->rt_forms[index].fill_brightness;
            fill_color[2] = p->rt_forms[index].fill_color[2] + p->rt_forms[index].fill_brightness;
          }
 
          err = _retouch_fill_cl(devid, dev_layer, roi_layer, dev_mask_scaled, &roi_mask_scaled, form_opacity,
                                  fill_color, gd);
        }
        else
          fprintf(stderr, "rt_process_forms: unknown algorithm %i\n", algo);
 
        if(mask_display)
          rt_copy_mask_to_alpha_cl(devid, dev_layer, roi_layer, dev_mask_scaled, &roi_mask_scaled, form_opacity,
                                    gd);
      }
 
      if(usr_d->stats)
      {
        usr_d->stats->shapes_applied++;
        usr_d->stats->algo_seconds += dt_get_wtime() - algo_start;
      }
 
      rt_release_shape(&shape);
      dt_opencl_release_mem_object(dev_mask_scaled);
    }
  }
 
  return err;
}
 
int process_cl(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece, cl_mem dev_in, cl_mem dev_out)
{
  const dt_iop_roi_t *const roi_in = &piece->roi_in;
  const dt_iop_roi_t *const roi_out = &piece->roi_out;
  const dt_iop_retouch_params_t *p = (const dt_iop_retouch_params_t *)piece->data;
  dt_iop_retouch_global_data_t *gd = (dt_iop_retouch_global_data_t *)self->global_data;
  dt_iop_retouch_gui_data_t *g = (dt_iop_retouch_gui_data_t *)dt_iop_gui_data(self);
 
  cl_int err = CL_SUCCESS;
  const int devid = pipe->devid;
 
  dt_iop_roi_t roi_retouch = *roi_in;
  dt_iop_roi_t *roi_rt = &roi_retouch;
 
  const int ch = piece->dsc_in.channels;
  retouch_user_data_t usr_data = { 0 };
  rt_memo_stats_t counters = { 0 };
  const gboolean counting = rt_perf_enabled();
  const double render_start = counting ? dt_get_wtime() : 0.0;
  dwt_params_cl_t *dwt_p = NULL;
 
  const int gui_active = (self->dev) ? (self == self->dev->gui_module) : 0;
  const int display_wavelet_scale = (g && gui_active) ? g->display_wavelet_scale : 0;
 
  // we will do all the clone, heal, etc on the input image,
  // this way the source for one algorithm can be the destination from a previous one
  const cl_mem in_retouch = dt_opencl_alloc_device_buffer(devid, sizeof(float) * ch * roi_rt->width * roi_rt->height);
  if(IS_NULL_PTR(in_retouch))
  {
    dt_print(DT_DEBUG_OPENCL, "[retouch process_cl] error allocating memory for wavelet decompose on device %d\n", devid);
    err = CL_MEM_OBJECT_ALLOCATION_FAILURE;
    goto cleanup;
  }
 
  // copy input image to the new buffer
  {
    size_t origin[] = { 0, 0, 0 };
    size_t region[] = { roi_rt->width, roi_rt->height, 1 };
    err = dt_opencl_enqueue_copy_image_to_buffer(devid, dev_in, in_retouch, origin, region, 0);
    if(err != CL_SUCCESS) goto cleanup;
  }
 
  // user data passed from the decompose routine to the one that process each scale
  usr_data.self = self;
  usr_data.pipe = pipe;
  usr_data.piece = piece;
  usr_data.roi = *roi_rt;
  usr_data.mask_display = 0;
  usr_data.suppress_mask = (g && g->suppress_mask && self->dev->gui_attached && (self == self->dev->gui_module)
                            && (pipe == self->dev->pipe));
  usr_data.display_scale = p->curr_scale;
  usr_data.stats = counting ? &counters : NULL;
 
  // init the decompose routine
  dwt_p = dt_dwt_init_cl(devid, in_retouch, roi_rt->width, roi_rt->height, p->num_scales,
                         (!display_wavelet_scale
                          || pipe->type != DT_DEV_PIXELPIPE_FULL) ? 0 : p->curr_scale,
                         p->merge_from_scale, &usr_data,
                         roi_in->scale);
  if(IS_NULL_PTR(dwt_p))
  {
    dt_print(DT_DEBUG_OPENCL, "[retouch process_cl] error initializing wavelet decompose on device %d\n", devid);
    err = CL_MEM_OBJECT_ALLOCATION_FAILURE;
    goto cleanup;
  }
 
  // check if this module should expose mask.
  // Must mirror process_internal()'s CPU condition exactly: g->mask_display OR display_wavelet_scale,
  // not g->mask_display alone. Missing the wavelet-scale branch meant a wavelet-only OpenCL preview
  // never cleared alpha, never set pipe->mask_display, and so never made the downstream color-pipeline
  // modules bypass -- they ran their normal processing on the wavelet-domain buffer instead of getting
  // skipped, corrupting the preview.
  if(pipe->type == DT_DEV_PIXELPIPE_FULL && g && (g->mask_display || display_wavelet_scale)
     && self->dev->gui_attached
     && (self == self->dev->gui_module) && (pipe == self->dev->pipe))
  {
    const int kernel = gd->kernel_retouch_clear_alpha;
    const size_t sizes[] = { ROUNDUPDWD(roi_rt->width, devid), ROUNDUPDHT(roi_rt->height, devid), 1 };
 
    dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&in_retouch);
    dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(int), (void *)&(roi_rt->width));
    dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&(roi_rt->height));
    err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
    if(err != CL_SUCCESS) goto cleanup;
 
    ((dt_dev_pixelpipe_t *)pipe)->mask_display = g->mask_display ? DT_DEV_PIXELPIPE_DISPLAY_MASK : DT_DEV_PIXELPIPE_DISPLAY_PASSTHRU;
    ((dt_dev_pixelpipe_t *)pipe)->bypass_blendif = 1;
    usr_data.mask_display = 1;
  }
 
  if(pipe->type == DT_DEV_PIXELPIPE_FULL)
  {
    // check if the image support this number of scales
    if(gui_active)
    {
      const int max_scales = dwt_get_max_scale_cl(dwt_p);
      if(dwt_p->scales > max_scales)
      {
        dt_control_log(_("max scale is %i for this image size"), max_scales);
      }
    }
    // get first scale visible at this zoom level
    if(g) g->first_scale_visible = dt_dwt_first_scale_visible_cl(dwt_p);
  }
 
  // decompose it
  err = dwt_decompose_cl(dwt_p, rt_process_forms_cl);
  if(err != CL_SUCCESS) goto cleanup;
 
  if(counting) rt_report_render(pipe, roi_rt, &counters, render_start, "on GPU");
 
  dt_aligned_pixel_t levels = { p->preview_levels[0], p->preview_levels[1], p->preview_levels[2] };
 
  // process auto levels
  if(g && pipe->type == DT_DEV_PIXELPIPE_FULL)
  {
    dt_iop_gui_enter_critical_section(self);
    if(g->preview_auto_levels == 1 && !dt_gui_widgets_suppressed())
    {
      g->preview_auto_levels = -1;
 
      dt_iop_gui_leave_critical_section(self);
 
      levels[0] = levels[1] = levels[2] = 0;
      err = rt_process_stats_cl(self, pipe, devid, in_retouch, roi_rt->width, roi_rt->height, levels);
      if(err != CL_SUCCESS) goto cleanup;
 
      rt_clamp_minmax(levels, levels);
 
      for(int i = 0; i < 3; i++) g->preview_levels[i] = levels[i];
 
      dt_iop_gui_enter_critical_section(self);
      g->preview_auto_levels = 2;
    }
    dt_iop_gui_leave_critical_section(self);
  }
 
  // if user wants to preview a detail scale adjust levels
  if(dwt_p->return_layer > 0 && dwt_p->return_layer < dwt_p->scales + 1)
  {
    err = rt_adjust_levels_cl(self, pipe, devid, in_retouch, roi_rt->width, roi_rt->height, levels);
    if(err != CL_SUCCESS) goto cleanup;
  }
 
  // copy alpha channel if needed
  if((pipe->mask_display & DT_DEV_PIXELPIPE_DISPLAY_MASK) && g && !g->mask_display)
  {
    const int kernel = gd->kernel_retouch_copy_alpha;
    const size_t sizes[] = { ROUNDUPDWD(roi_rt->width, devid), ROUNDUPDHT(roi_rt->height, devid), 1 };
 
    dt_opencl_set_kernel_arg(devid, kernel, 0, sizeof(cl_mem), (void *)&dev_in);
    dt_opencl_set_kernel_arg(devid, kernel, 1, sizeof(cl_mem), (void *)&in_retouch);
    dt_opencl_set_kernel_arg(devid, kernel, 2, sizeof(int), (void *)&(roi_rt->width));
    dt_opencl_set_kernel_arg(devid, kernel, 3, sizeof(int), (void *)&(roi_rt->height));
    err = dt_opencl_enqueue_kernel_2d(devid, kernel, sizes);
    if(err != CL_SUCCESS) goto cleanup;
  }
 
  // return final image
  err = rt_copy_in_to_out_cl(devid, in_retouch, roi_in, dev_out, roi_out, 0, 0,
                             gd->kernel_retouch_copy_buffer_to_image);
 
cleanup:
  if(dwt_p) dt_dwt_free_cl(dwt_p);
 
  dt_opencl_release_mem_object(in_retouch);
 
  if(err != CL_SUCCESS) dt_print(DT_DEBUG_OPENCL, "[opencl_retouch] couldn't enqueue kernel! %d\n", err);
 
  return (err == CL_SUCCESS) ? TRUE : FALSE;
}
#endif
 
static void rt_menu_select_algorithm_callback(GtkWidget *widget, gpointer user_data)
{
  dt_iop_module_t *self = (dt_iop_module_t *)user_data;
  dt_iop_retouch_params_t *p = (dt_iop_retouch_params_t *)self->params;
 
  const int formid = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "formid"));
  const int algo = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), "algo"));
  const int index = rt_get_index_from_formid(p, formid);
  if(index < 0) return;
  if(algo < DT_IOP_RETOUCH_CLONE || algo > DT_IOP_RETOUCH_FILL) return;
  if(p->rt_forms[index].algorithm == algo) return;
  dt_masks_form_t *form = dt_masks_get_from_id(self->dev, formid);
  if(IS_NULL_PTR(form)) return;
 
  // Apply the new algorithm to the form
  p->rt_forms[index].algorithm = algo;
 
  // Switch the clone type of the form
  dt_masks_type_t masks_type = form->type;
  if(algo == DT_IOP_RETOUCH_CLONE || algo == DT_IOP_RETOUCH_HEAL)
  {
    masks_type |= DT_MASKS_CLONE;
    masks_type &= ~DT_MASKS_NON_CLONE;
  }
  else
  {
    masks_type &= ~DT_MASKS_CLONE;
    masks_type |= DT_MASKS_NON_CLONE;
  }
  form->type = masks_type;
 
  // Update GUI
  rt_load_shape_algo_in_gui(self, formid);
 
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
 
int populate_masks_context_menu(struct dt_iop_module_t *self, GtkWidget *menu, const int formid,const float pzx, const float pzy)
{
  const dt_iop_retouch_params_t *p = (const dt_iop_retouch_params_t *)self->params;
  const int index = rt_get_index_from_formid(p, formid);
  if(index == -1)
  {
    fprintf(stderr, "populate_masks_context_menu: missing form=%i from array\n", formid);
    return FALSE;
  }
 
  GtkWidget *menu_item = ctx_gtk_menu_item_new_with_markup(_("Retouch correction"), menu, NULL, NULL);
  GtkWidget *sub_menu = gtk_menu_new();
  gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), sub_menu);
 
  static const struct
  {
    dt_iop_retouch_algo_type_t algo;
    const char *name;
  } algo_entries[] = {{ DT_IOP_RETOUCH_CLONE, N_("Clone") },
                      { DT_IOP_RETOUCH_HEAL, N_("Heal") },
                      { DT_IOP_RETOUCH_BLUR, N_("Blur") },
                      { DT_IOP_RETOUCH_FILL, N_("Fill") },};
 
  for(size_t i = 0; i < G_N_ELEMENTS(algo_entries); i++)
  {
    const gboolean is_selected = (p->rt_forms[index].algorithm == algo_entries[i].algo);
    const char *const label = _(algo_entries[i].name);
    GtkWidget *algo_item = ctx_gtk_check_menu_item_new_with_markup(label, sub_menu,
                                                          is_selected ? NULL : rt_menu_select_algorithm_callback, self,
                                                          is_selected, FALSE);
 
    g_object_set_data(G_OBJECT(algo_item), "formid", GINT_TO_POINTER(formid));
    g_object_set_data(G_OBJECT(algo_item), "algo", GINT_TO_POINTER(algo_entries[i].algo));
  }
 
  return TRUE;
}
// clang-format off
// modelines: These editor modelines have been set for all relevant files by tools/update_modelines.py
// vim: shiftwidth=2 expandtab tabstop=2 cindent
// kate: tab-indents: off; indent-width 2; replace-tabs on; indent-mode cstyle; remove-trailing-spaces modified;
// clang-format on