spots.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2011 Henrik Andersson.
    Copyright (C) 2011-2013, 2016 johannes hanika.
    Copyright (C) 2011 Robert Bieber.
    Copyright (C) 2011 Rostyslav Pidgornyi.
    Copyright (C) 2011-2014, 2016-2019 Tobias Ellinghaus.
    Copyright (C) 2012-2013, 2015, 2017-2022 Pascal Obry.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2012-2014, 2016, 2020 Ulrich Pegelow.
    Copyright (C) 2013-2014, 2016, 2019-2021 Aldric Renaudin.
    Copyright (C) 2013-2016 Roman Lebedev.
    Copyright (C) 2013 Simon Spannagel.
    Copyright (C) 2015 Pedro Côrte-Real.
    Copyright (C) 2016-2017 Peter Budai.
    Copyright (C) 2017 Heiko Bauke.
    Copyright (C) 2018-2020, 2023, 2025-2026 Aurélien PIERRE.
    Copyright (C) 2018 Edgardo Hoszowski.
    Copyright (C) 2018 Maurizio Paglia.
    Copyright (C) 2018 rawfiner.
    Copyright (C) 2019 Andreas Schneider.
    Copyright (C) 2020 Chris Elston.
    Copyright (C) 2020 Diederik Ter Rahe.
    Copyright (C) 2020 Hubert Kowalski.
    Copyright (C) 2020 Marco.
    Copyright (C) 2020-2021 Ralf Brown.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2022 Philipp Lutz.
    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 "config.h"
#endif
#include "develop/masks_gui.h"
#include "system/macros.h"
#include "system/openmp.h"
#include "system/target_clones.h"
#include "system/mem_alloc.h"
#include "common/module_versioning.h"
#include "control/control.h"
#include "develop/blend.h"
#include "develop/blend_gui.h"
#include "develop/imageop.h"
#include "develop/imageop_gui.h"
#include "develop/masks.h"
 
#include "iop/iop_api.h"
#include <gtk/gtk.h>
#include <stdlib.h>
#include "widgets/label.h"
 
 
// this is the version of the modules parameters,
// and includes version information about compile-time dt
DT_MODULE_INTROSPECTION(2, dt_iop_spots_params_t)
 
typedef struct dt_iop_spots_params_t
{
  int clone_id[64];
  int clone_algo[64];
} dt_iop_spots_params_t;
 
typedef struct dt_iop_spots_gui_data_t
{
  GtkLabel *label;
  GtkWidget *bt_path, *bt_circle, *bt_ellipse, *bt_edit_masks;
} dt_iop_spots_gui_data_t;
 
typedef struct dt_iop_spots_params_t dt_iop_spots_data_t;
 
 
// this returns a translatable name
const char *name()
{
  return _("spot removal");
}
 
const char *deprecated_msg()
{
  return _("this module is deprecated. please use the retouch module instead.");
}
 
const char **description(struct dt_iop_module_t *self)
{
  return dt_iop_set_description(self, _("remove sensor dust spots"),
                                      _("corrective"),
                                      _("linear, RGB, scene-referred"),
                                      _("geometric, raw"),
                                      _("linear, RGB, scene-referred"));
}
 
int default_group()
{
  return IOP_GROUP_EFFECTS;
}
 
int flags()
{
  return IOP_FLAGS_SUPPORTS_BLENDING | IOP_FLAGS_NO_MASKS | IOP_FLAGS_DEPRECATED | 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;
}
 
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 == 2)
  {
    typedef struct dt_iop_spots_v1_t
    {
      float x, y;
      float xc, yc;
      float radius;
    } dt_iop_spots_v1_t;
    typedef struct dt_iop_spots_params_v1_t
    {
      int num_spots;
      dt_iop_spots_v1_t spot[32];
    } dt_iop_spots_params_v1_t;
 
    dt_iop_spots_params_v1_t *o = (dt_iop_spots_params_v1_t *)old_params;
    dt_iop_spots_params_t *n = (dt_iop_spots_params_t *)new_params;
    dt_iop_spots_params_t *d = (dt_iop_spots_params_t *)self->default_params;
 
    *n = *d; // start with a fresh copy of default parameters
    for(int i = 0; i < o->num_spots; i++)
    {
      // we have to register a new circle mask
      dt_masks_form_t *form = dt_masks_create(DT_MASKS_CIRCLE | DT_MASKS_CLONE);
 
      // spots v1 was before raw orientation changes
      form->version = 1;
 
      dt_masks_node_circle_t *circle = (dt_masks_node_circle_t *)(malloc(sizeof(dt_masks_node_circle_t)));
      circle->center[0] = o->spot[i].x;
      circle->center[1] = o->spot[i].y;
      circle->radius = o->spot[i].radius;
      circle->border = 0.0f;
      form->points = g_list_append(form->points, circle);
      form->source[0] = o->spot[i].xc;
      form->source[1] = o->spot[i].yc;
 
      // adapt for raw orientation changes
      dt_masks_legacy_params(self->dev, form, form->version, dt_masks_version());
 
      dt_masks_gui_form_save_creation(self->dev, self, form, NULL);
 
      // and add it to the module params
      n->clone_id[i] = form->formid;
      n->clone_algo[i] = 2;
    }
 
    // look for spot history num, if not found then it will be added
    // at the end of the list.
    int last_spot_num = 0;
    int count = 0;
    for(GList *l = self->dev->history; l; l = g_list_next(l))
    {
      dt_dev_history_item_t *item = (dt_dev_history_item_t *)l->data;
      count++;
      if(!strcmp(item->op_name, "spots")) last_spot_num = item->num;
    }
 
    if(last_spot_num == 0) last_spot_num = count;
 
    // record all forms for this module & history num
    // also record the group in the blend params.
 
    dt_develop_blend_params_t *bp = self->blend_params;
 
    for(GList *l = self->dev->forms; l; l = g_list_next(l))
    {
      dt_masks_form_t *form = (dt_masks_form_t *)l->data;
      if(form && (form->type & DT_MASKS_GROUP))
      {
        bp->mask_id = form->formid;
      }
      dt_masks_write_masks_history_item(self->dev->image_storage.id, last_spot_num, form);
    }
 
    return 0;
  }
  return 1;
}
 
static void _resynch_params(struct dt_iop_module_t *self)
{
  dt_iop_spots_params_t *p = (dt_iop_spots_params_t *)self->params;
  dt_develop_blend_params_t *bp = self->blend_params;
 
  // we create 2 new buffers
  int nid[64] = { 0 };
  int nalgo[64] = { 2 };
 
  // we go through all forms in blend params
  dt_masks_form_t *grp = dt_masks_get_from_id(self->dev, bp->mask_id);
  if(grp && (grp->type & DT_MASKS_GROUP))
  {
    int i = 0;
    for(GList *forms = grp->points; (i < 64) && forms; forms = g_list_next(forms))
    {
      dt_masks_form_group_t *grpt = (dt_masks_form_group_t *)forms->data;
      nid[i] = grpt->formid;
      for(int j = 0; j < 64; j++)
      {
        if(p->clone_id[j] == nid[i])
        {
          nalgo[i] = p->clone_algo[j];
          break;
        }
      }
      i++;
    }
  }
 
  // we reaffect params
  for(int i = 0; i < 64; i++)
  {
    p->clone_algo[i] = nalgo[i];
    p->clone_id[i] = nid[i];
  }
}
 
 
static gboolean _reset_form_creation(GtkWidget *widget, dt_iop_module_t *self)
{
  dt_iop_spots_gui_data_t *g = (dt_iop_spots_gui_data_t *)dt_iop_gui_data(self);
 
  // we check the nb of shapes limit
  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);
 
  if(nb >= 64)
  {
    dt_control_log(_("spot module is limited to 64 shapes. please add a new instance !"));
  }
 
  if(nb < 64
     && (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->bt_path))
         || gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->bt_circle))
         || gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(g->bt_ellipse))))
  {
    // we unset the creation mode
    dt_masks_change_form_gui(self->dev, NULL);
  }
  if(widget != g->bt_path || nb >= 64) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_path), FALSE);
  if(widget != g->bt_circle || nb >= 64) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_circle), FALSE);
  if(widget != g->bt_ellipse || nb >= 64) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_ellipse), FALSE);
 
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_edit_masks), FALSE);
 
  return (nb < 64);
}
 
static int _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))
      {
        dt_masks_form_group_t *grpt = (dt_masks_form_group_t *)forms->data;
        if(grpt)
        {
          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);
  }
  return being_added;
}
 
static gboolean _add_shape(GtkWidget *widget, dt_iop_module_t *self)
{
  //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;
 
  if(!_reset_form_creation(widget, self)) return TRUE;
  if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) return FALSE;
 
  dt_iop_spots_gui_data_t *g = (dt_iop_spots_gui_data_t *)dt_iop_gui_data(self);
  // we want to be sure that the iop has focus
  dt_iop_request_focus(self);
  // we create the new form
  dt_masks_type_t type = DT_MASKS_CIRCLE;
  if(widget == g->bt_path)
    type = DT_MASKS_POLYGON;
  else if(widget == g->bt_circle)
    type = DT_MASKS_CIRCLE;
  else if(widget == g->bt_ellipse)
    type = DT_MASKS_ELLIPSE;
 
 
  const dt_masks_type_t masks_type = (type | DT_MASKS_CLONE);
  dt_masks_creation_mode_enter(self->dev, self, masks_type);
 
 
  dt_control_queue_redraw_center();
  return FALSE;
}
 
static gboolean _add_shape_callback(GtkWidget *widget, GdkEventButton *e, dt_iop_module_t *self)
{
  if(dt_gui_widgets_suppressed()) return FALSE;
 
  const dt_iop_spots_gui_data_t *g = (dt_iop_spots_gui_data_t *)dt_iop_gui_data(self);
 
  _add_shape(widget, self);
 
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_circle), _shape_is_being_added(self, DT_MASKS_CIRCLE));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_ellipse), _shape_is_being_added(self, DT_MASKS_ELLIPSE));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_path), _shape_is_being_added(self, DT_MASKS_POLYGON));
 
  return TRUE;
}
 
static gboolean _edit_masks(GtkWidget *widget, GdkEventButton *e, 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_spots_gui_data_t *g = (dt_iop_spots_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);
 
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_path), FALSE);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_circle), FALSE);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_ellipse), FALSE);
 
  dt_gui_freeze_begin();
 
  dt_iop_color_picker_reset(self, TRUE);
 
  dt_masks_set_edit_mode(self, self->dev->form_gui->edit_mode == DT_MASKS_EDIT_FULL ? DT_MASKS_EDIT_OFF : DT_MASKS_EDIT_FULL);
 
  // update edit shapes status
  dt_develop_blend_params_t *bp = self->blend_params;
  dt_masks_form_t *grp = dt_masks_get_from_id(self->dev, bp->mask_id);
  //only toggle shape show button if shapes exist
  if(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);
  }
 
  dt_gui_freeze_end();
 
  dt_control_queue_redraw_center();
 
  return TRUE;
}
 
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;
}
 
// 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;
 
  int roir = roi_in->width + roi_in->x;
  int roib = roi_in->height + roi_in->y;
  int roix = roi_in->x;
  int roiy = roi_in->y;
 
  // This runs on the pipeline thread: the group id comes from the piece and the shapes from the
  // run's snapshot, never from self->blend_params and the GUI-owned dev->forms.
  const dt_develop_blend_params_t *bp = (const dt_develop_blend_params_t *)piece->blendop_data;
 
  // We iterate through all spots or polygons
  const dt_masks_form_t *grp = dt_masks_get_from_id_in_pipe(pipe, bp->mask_id);
  if(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;
      // we get the spot, and skip it when it is outside the roi
      dt_masks_form_t *form = dt_masks_get_from_id_in_pipe(pipe, grpt->formid);
      if(IS_NULL_PTR(form) || !dt_masks_form_is_in_roi(self, pipe, piece, form, roi_in, roi_out)) continue;
 
      // we get the area for the source
      dt_masks_area_t area;
      if(dt_masks_get_source_area(self, pipe, piece, form, &area) != DT_MASKS_RASTER_OK) continue;
      dt_masks_area_scale(&area, roi_in->scale);
 
      // we enlarge the roi if needed
      roiy = fminf(area.y, roiy);
      roix = fminf(area.x, roix);
      roir = fmaxf(area.x + area.width, roir);
      roib = fmaxf(area.y + area.height, roib);
    }
  }
 
  // 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(roix, 0, scwidth - 1);
  roi_in->y = CLAMP(roiy, 0, scheight - 1);
  roi_in->width = CLAMP(roir - roi_in->x, 1, scwidth + .5f - roi_in->x);
  roi_in->height = CLAMP(roib - roi_in->y, 1, scheight + .5f - roi_in->y);
}
 
__DT_CLONE_TARGETS__
static void 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;
  }
}
 
static inline __attribute__((always_inline)) int masks_point_calc_delta(dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe,
                                  const dt_iop_roi_t *roi, const float *target, const float *source, int *dx,
                                  int *dy)
{
  dt_boundingbox_t points;
  masks_point_denormalize(pipe, roi, target, 1, points);
  masks_point_denormalize(pipe, roi, source, 1, points + 2);
 
  const int res = dt_dev_distort_transform_plus(pipe, self->iop_order, DT_DEV_TRANSFORM_DIR_BACK_INCL, points, 2);
  if(!res) return res;
 
  *dx = points[0] - points[2];
  *dy = points[1] - points[3];
 
  return res;
}
 
static inline __attribute__((always_inline)) int masks_get_delta(dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe,
                           const dt_iop_roi_t *roi,
                           dt_masks_form_t *form, int *dx, int *dy)
{
  int res = 0;
 
  if(form->type & DT_MASKS_POLYGON)
  {
    dt_masks_node_polygon_t *pt = (dt_masks_node_polygon_t *)form->points->data;
 
    res = masks_point_calc_delta(self, pipe, roi, pt->node, form->source, dx, dy);
  }
  else if(form->type & DT_MASKS_CIRCLE)
  {
    dt_masks_node_circle_t *pt = (dt_masks_node_circle_t *)form->points->data;
 
    res = masks_point_calc_delta(self, pipe, roi, pt->center, form->source, dx, dy);
  }
  else if(form->type & DT_MASKS_ELLIPSE)
  {
    dt_masks_node_ellipse_t *pt = (dt_masks_node_ellipse_t *)form->points->data;
 
    res = masks_point_calc_delta(self, pipe, roi, pt->center, form->source, dx, dy);
  }
 
  return res;
}
 
__DT_CLONE_TARGETS__
// The buffers a spot is cloned between.
typedef struct _spots_buffers_t
{
  const float *in;
  float *out;
  const dt_iop_roi_t *roi_in;
  const dt_iop_roi_t *roi_out;
  int ch;
} _spots_buffers_t;
 
// Clone a circle spot with the historical smoothstep falloff (clone_algo 1). Returns non-zero on
// allocation failure.
// Blend the disc of radius `rad` centred on (posx + rad, posy + rad) with the same disc shifted
// by (-dx, -dy), weighted by the separable falloff `filter`. Pixels outside either ROI are left
// alone.
static void _spots_blend_disc(const _spots_buffers_t *buffers, const float *const filter, const int rad,
                              const int posx, const int posy, const int dx, const int dy)
{
  const float *in = buffers->in;
  float *out = buffers->out;
  const dt_iop_roi_t *const roi_in = buffers->roi_in;
  const dt_iop_roi_t *const roi_out = buffers->roi_out;
  const int ch = buffers->ch;
  const int fw = 2 * rad;
  const int fh = 2 * rad;
 
  for(int yy = posy; yy < posy + fh; yy++)
  {
    // we test if we are inside roi_out
    if(yy < roi_out->y || yy >= roi_out->y + roi_out->height) continue;
    // we test if the source point is inside roi_in
    if(yy - dy < roi_in->y || yy - dy >= roi_in->y + roi_in->height) continue;
    for(int xx = posx; xx < posx + fw; xx++)
    {
      // we test if we are inside roi_out
      if(xx < roi_out->x || xx >= roi_out->x + roi_out->width) continue;
      // we test if the source point is inside roi_in
      if(xx - dx < roi_in->x || xx - dx >= roi_in->x + roi_in->width) continue;
 
      const float f = filter[xx - posx + 1] * filter[yy - posy + 1];
      for(int c = 0; c < ch; c++)
        out[ch * ((size_t)roi_out->width * (yy - roi_out->y) + xx - roi_out->x) + c]
            = out[ch * ((size_t)roi_out->width * (yy - roi_out->y) + xx - roi_out->x) + c] * (1.0f - f)
              + in[ch * ((size_t)roi_in->width * (yy - dy - roi_in->y) + xx - dx - roi_in->x) + c] * f;
    }
  }
}
 
static int _spots_clone_circle(const struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe,
                               const dt_masks_form_t *form, const _spots_buffers_t *buffers)
{
  const dt_iop_roi_t *const roi_in = buffers->roi_in;
 
  dt_masks_node_circle_t *circle = (dt_masks_node_circle_t *)form->points->data;
 
  dt_boundingbox_t points;
  masks_point_denormalize(pipe, roi_in, circle->center, 1, points);
  masks_point_denormalize(pipe, roi_in, form->source, 1, points + 2);
 
  if(!dt_dev_distort_transform_plus(pipe, self->iop_order, DT_DEV_TRANSFORM_DIR_BACK_INCL, points, 2))
  {
    return 0;
  }
 
  // convert from world space:
  float radius10[2] = { circle->radius, circle->radius };
  float radf[2];
  masks_point_denormalize(pipe, roi_in, radius10, 1, radf);
 
  const int rad = MIN(radf[0], radf[1]);
  const int posx = points[0] - rad;
  const int posy = points[1] - rad;
  const int posx_source = points[2] - rad;
  const int posy_source = points[3] - rad;
  const int dx = posx - posx_source;
  const int dy = posy - posy_source;
 
  float *filter = malloc(sizeof(float) * (2 * rad + 1));
  if(IS_NULL_PTR(filter)) return 1;
 
  if(rad > 0)
  {
    for(int k = -rad; k <= rad; k++)
    {
      const float kk = 1.0f - fabsf(k / (float)rad);
      filter[rad + k] = kk * kk * (3.0f - 2.0f * kk);
    }
  }
  else
  {
    filter[0] = 1.0f;
  }
 
  _spots_blend_disc(buffers, filter, rad, posx, posy, dx, dy);
 
  dt_free(filter);
  return 0;
}
 
// Clone any spot through its rasterised mask. Returns non-zero when the mask cannot be built.
static int _spots_clone_mask(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe,
                             const dt_dev_pixelpipe_iop_t *piece, dt_masks_form_t *form, const float opacity,
                             const _spots_buffers_t *buffers)
{
  const float *in = buffers->in;
  float *out = buffers->out;
  const dt_iop_roi_t *const roi_in = buffers->roi_in;
  const dt_iop_roi_t *const roi_out = buffers->roi_out;
  const int ch = buffers->ch;
 
  // we get the mask
  float *mask = NULL;
  dt_masks_area_t area;
  /* Only a real failure aborts the module. A shape with nothing to draw (EMPTY) falls
   * through to the zero-size check below and is skipped like any other empty shape --
   * aborting here would silently drop every REMAINING shape in the group. The out
   * parameters are guaranteed written on every outcome, so that check is safe to reach. */
  if(dt_masks_get_mask(self, pipe, piece, form, &mask, &area) == DT_MASKS_RASTER_ERROR) return 1;
 
  // now we search the delta with the source; nothing to clone without one
  int dx = 0;
  int dy = 0;
  if(area.width < 1 || area.height < 1 || !masks_get_delta(self, pipe, roi_in, form, &dx, &dy)
     || (dx == 0 && dy == 0))
  {
    dt_pixelpipe_cache_free_align(mask);
    return 0;
  }
 
  const int fts = area.y * roi_in->scale;
  const int fhs = area.height * roi_in->scale;
  const int fls = area.x * roi_in->scale;
  const int fws = area.width * roi_in->scale;
 
  // now we do the pixel clone
  for(int yy = fts + 1; yy < fts + fhs - 1; yy++)
  {
    // we test if we are inside roi_out
    if(yy < roi_out->y || yy >= roi_out->y + roi_out->height) continue;
    // we test if the source point is inside roi_in
    if(yy - dy < roi_in->y || yy - dy >= roi_in->y + roi_in->height) continue;
    for(int xx = fls + 1; xx < fls + fws - 1; xx++)
    {
      // we test if we are inside roi_out
      if(xx < roi_out->x || xx >= roi_out->x + roi_out->width) continue;
      // we test if the source point is inside roi_in
      if(xx - dx < roi_in->x || xx - dx >= roi_in->x + roi_in->width) continue;
 
      const float f = mask[((int)((yy - fts) / roi_in->scale)) * area.width
                          + (int)((xx - fls) / roi_in->scale)] * opacity;
 
      for(int c = 0; c < ch; c++)
        out[ch * ((size_t)roi_out->width * (yy - roi_out->y) + xx - roi_out->x) + c]
            = out[ch * ((size_t)roi_out->width * (yy - roi_out->y) + xx - roi_out->x) + c] * (1.0f - f)
              + in[ch * ((size_t)roi_in->width * (yy - dy - roi_in->y) + xx - dx - roi_in->x) + c] * f;
    }
  }
  dt_pixelpipe_cache_free_align(mask);
  return 0;
}
 
static int _process(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, const 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, const int ch)
{
  dt_iop_spots_params_t *d = (dt_iop_spots_params_t *)piece->data;
  // Pipeline thread: see modify_roi_in() for why the piece and the run's snapshot, not the module.
  const dt_develop_blend_params_t *bp = (const dt_develop_blend_params_t *)piece->blendop_data;
 
// we don't modify most of the image:
  __OMP_PARALLEL_FOR__()
  for(int k = 0; k < roi_out->height; k++)
  {
    float *outb = out + (size_t)ch * k * roi_out->width;
    const float *inb = in + (size_t)ch * roi_in->width * (k + roi_out->y - roi_in->y)
                       + ch * (roi_out->x - roi_in->x);
    memcpy(outb, inb, sizeof(float) * roi_out->width * ch);
  }
 
  const _spots_buffers_t buffers = { .in = in, .out = out, .roi_in = roi_in, .roi_out = roi_out, .ch = ch };
 
  // iterate through all forms
  const dt_masks_form_t *grp = dt_masks_get_from_id_in_pipe(pipe, bp->mask_id);
  int pos = 0;
  if(grp && (grp->type & DT_MASKS_GROUP))
  {
    for(const GList *forms = grp->points; (pos < 64) && forms; pos++, forms = g_list_next(forms))
    {
      dt_masks_form_group_t *grpt = (dt_masks_form_group_t *)forms->data;
      // we get the spot
      dt_masks_form_t *form = dt_masks_get_from_id_in_pipe(pipe, grpt->formid);
      if(IS_NULL_PTR(form))
      {
        continue;
      }
 
      // if the form is outside the roi, we just skip it
      if(!dt_masks_form_is_in_roi(self, pipe, piece, form, roi_in, roi_out))
      {
        continue;
      }
 
      const int err = (d->clone_algo[pos] == 1 && (form->type & DT_MASKS_CIRCLE))
                          ? _spots_clone_circle(self, pipe, form, &buffers)
                          : _spots_clone_mask(self, pipe, piece, form, grpt->opacity, &buffers);
      if(err) return err;
    }
  }
  return 0;
}
 
int process(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece, const void *const i, void *const o)
{
  const dt_iop_roi_t *const roi_in = &piece->roi_in;
  const dt_iop_roi_t *const roi_out = &piece->roi_out;
  const float *in = (float *)i;
  float *out = (float *)o;
  return _process(self, pipe, piece, in, out, roi_in, roi_out, piece->dsc_in.channels);
}
 
void distort_mask(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, 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;
  if(_process(self, pipe, piece, in, out, roi_in, roi_out, 1)) return;
}
 
void init(dt_iop_module_t *module)
{
  // we don't need global data:
  module->global_data = NULL; // malloc(sizeof(dt_iop_spots_global_data_t));
  module->params = calloc(1, sizeof(dt_iop_spots_params_t));
  module->default_params = calloc(1, sizeof(dt_iop_spots_params_t));
  // our module is disabled by default
  // by default:
  module->default_enabled = 0;
  module->params_size = sizeof(dt_iop_spots_params_t);
  // init defaults:
  dt_iop_spots_params_t tmp = (dt_iop_spots_params_t){ { 0 }, { 2 } };
 
  memcpy(module->default_params, &tmp, sizeof(dt_iop_spots_params_t));
}
 
void gui_focus(struct dt_iop_module_t *self, gboolean in)
{
  if(self->enabled)
  {
    dt_iop_spots_gui_data_t *g = (dt_iop_spots_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;
 
      // update edit shapes status
      dt_develop_blend_params_t *bp = self->blend_params;
      dt_masks_form_t *grp = dt_masks_get_from_id(self->dev, bp->mask_id);
      //only toggle shape show button if shapes exist
      if(grp && (grp->type & DT_MASKS_GROUP) && grp->points)
      {
        if(bd->masks_shown == DT_MASKS_EDIT_OFF) dt_masks_set_edit_mode(self, DT_MASKS_EDIT_FULL);
 
        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);
      }
    }
    else
    {
      // lost focus, hide all shapes
      if (self->dev->form_gui->creation && self->dev->form_gui->creation_module == self)
        dt_masks_change_form_gui(self->dev, NULL);
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_path), FALSE);
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_circle), FALSE);
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_ellipse), FALSE);
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_edit_masks), FALSE);
      dt_masks_set_edit_mode(self, DT_MASKS_EDIT_OFF);
    }
  }
}
 
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)
{
  memcpy(piece->data, params, sizeof(dt_iop_spots_params_t));
}
 
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_spots_data_t));
  piece->data_size = sizeof(dt_iop_spots_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)
{
  _resynch_params(self);
  dt_iop_spots_gui_data_t *g = (dt_iop_spots_gui_data_t *)dt_iop_gui_data(self);
  // update clones count
  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, str);
  dt_free(str);
 
  // enable/disable shapes toolbar
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_circle), _shape_is_being_added(self, DT_MASKS_CIRCLE));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_path), _shape_is_being_added(self, DT_MASKS_POLYGON));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g->bt_ellipse), _shape_is_being_added(self, DT_MASKS_ELLIPSE));
 
  // 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(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);
  }
  dt_control_queue_redraw_center();
}
 
void gui_init(dt_iop_module_t *self)
{
  dt_iop_spots_gui_data_t *g = IOP_GUI_ALLOC(spots);
 
  self->gui->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_GUI_BOX_SPACING);
 
  GtkWidget *hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
  gtk_box_pack_start(GTK_BOX(hbox), dt_ui_label_new(_("number of strokes:")), FALSE, TRUE, 0);
  g->label = GTK_LABEL(dt_ui_label_new("-1"));
  gtk_widget_set_tooltip_text(hbox, _("click on a shape and drag on canvas.\nuse the mouse wheel "
                                      "to adjust size.\nright click to remove a shape."));
 
  g->bt_edit_masks = dt_iop_togglebutton_new(self, NULL, N_("show and edit shapes"), NULL,
                                             G_CALLBACK(_edit_masks), TRUE, 0, 0,
                                             dtgtk_cairo_paint_masks_edit, hbox);
 
  g->bt_path = dt_iop_togglebutton_new(self, N_("shapes"), N_("add path"), N_("add multiple paths"),
                                       G_CALLBACK(_add_shape_callback), TRUE, 0, 0,
                                       dtgtk_cairo_paint_masks_polygon, hbox);
 
  g->bt_ellipse = dt_iop_togglebutton_new(self, N_("shapes"), N_("add ellipse"), N_("add multiple ellipses"),
                                          G_CALLBACK(_add_shape_callback), TRUE, 0, 0,
                                          dtgtk_cairo_paint_masks_ellipse, hbox);
 
  g->bt_circle = dt_iop_togglebutton_new(self, N_("shapes"), N_("add circle"), N_("add multiple circles"),
                                         G_CALLBACK(_add_shape_callback), TRUE, 0, 0,
                                         dtgtk_cairo_paint_masks_circle, hbox);
 
  gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(g->label), FALSE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(self->gui->widget), hbox, TRUE, TRUE, 0);
}
 
void gui_reset(struct dt_iop_module_t *self)
{
  // hide the previous masks
  dt_masks_reset_form_gui(self->dev);
}
 
// 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