develop/masks/brush.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2013-2016, 2021 Aldric Renaudin.
    Copyright (C) 2013 Jean-Sébastien Pédron.
    Copyright (C) 2013, 2017, 2019-2022 Pascal Obry.
    Copyright (C) 2013 Simon Spannagel.
    Copyright (C) 2013-2017 Tobias Ellinghaus.
    Copyright (C) 2013-2016, 2019 Ulrich Pegelow.
    Copyright (C) 2014-2016 Roman Lebedev.
    Copyright (C) 2017-2019 Edgardo Hoszowski.
    Copyright (C) 2017 Matthieu Moy.
    Copyright (C) 2018 johannes hanika.
    Copyright (C) 2020, 2022 Chris Elston.
    Copyright (C) 2020 GrahamByrnes.
    Copyright (C) 2020 Heiko Bauke.
    Copyright (C) 2020-2021 Hubert Kowalski.
    Copyright (C) 2020-2021 Ralf Brown.
    Copyright (C) 2021 Diederik Ter Rahe.
    Copyright (C) 2021 luzpaz.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2023, 2025-2026 Aurélien PIERRE.
    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/>.
*/
#include "control/control.h"
#include "math/math.h"
#include "system/macros.h"
#include "system/openmp.h"
#include "system/mem_alloc.h"
#include "common/logging.h"
#include "common/times.h"
#include "common/glib_utils.h"
#include "caches/pixelpipe_cache_alloc.h"
#include "common/conf.h"
#include "develop/imageop.h"
#include "develop/masks/masks_distort.h"
#include "develop/masks.h"
#include "develop/masks_gui.h"
#include "develop/blend_gui.h"   // dt_iop_gui_blend_masks_update()
#include "develop/masks/masks_functions.h"
#include "develop/masks/masks_touched.h"
#include "math/openmp_maths.h"
#include "gui/actions/menu.h"
#include "widgets/accelerators.h"
#include "widgets/widget_settings.h"
 
#define FADING_MIN 0.00001f
#define FADING_MAX 1.0f
 
#define BORDER_MIN 0.00005f
#define BORDER_MAX 0.5f
 
static float _brush_point_line_distance2(int point_index, int point_count,
                                         const float *point_buffer, const float *payload_buffer)
{
  const float point_x = point_buffer[2 * point_index];
  const float point_y = point_buffer[2 * point_index + 1];
  const float point_border = payload_buffer[4 * point_index];
  const float point_fading = payload_buffer[4 * point_index + 1];
  const float point_density = payload_buffer[4 * point_index + 2];
  const float start_x = point_buffer[0];
  const float start_y = point_buffer[1];
  const float start_border = payload_buffer[0];
  const float start_fading = payload_buffer[1];
  const float start_density = payload_buffer[2];
  const float end_x = point_buffer[2 * (point_count - 1)];
  const float end_y = point_buffer[2 * (point_count - 1) + 1];
  const float end_border = payload_buffer[4 * (point_count - 1)];
  const float end_fading = payload_buffer[4 * (point_count - 1) + 1];
  const float end_density = payload_buffer[4 * (point_count - 1) + 2];
  const float bweight = 1.0f;
  const float hweight = 0.01f;
  const float dweight = 0.01f;
 
  const float segment_dx = end_x - start_x;
  const float segment_dy = end_y - start_y;
  const float segment_db = end_border - start_border;
  const float segment_dh = end_fading - start_fading;
  const float segment_dd = end_density - start_density;
 
  const float dot = (point_x - start_x) * segment_dx + (point_y - start_y) * segment_dy;
  const float segment_len2 = sqf(segment_dx) + sqf(segment_dy);
  const float t = dot / segment_len2;
 
  float dx = 0.0f, dy = 0.0f, db = 0.0f, dh = 0.0f, dd = 0.0f;
 
  if(segment_len2 == 0.0f)
  {
    dx = point_x - start_x;
    dy = point_y - start_y;
    db = point_border - start_border;
    dh = point_fading - start_fading;
    dd = point_density - start_density;
  }
  else if(t < 0.0f)
  {
    dx = point_x - start_x;
    dy = point_y - start_y;
    db = point_border - start_border;
    dh = point_fading - start_fading;
    dd = point_density - start_density;
  }
  else if(t > 1.0f)
  {
    dx = point_x - end_x;
    dy = point_y - end_y;
    db = point_border - end_border;
    dh = point_fading - end_fading;
    dd = point_density - end_density;
  }
  else
  {
    dx = point_x - (start_x + t * segment_dx);
    dy = point_y - (start_y + t * segment_dy);
    db = point_border - (start_border + t * segment_db);
    dh = point_fading - (start_fading + t * segment_dh);
    dd = point_density - (start_density + t * segment_dd);
  }
 
  return sqf(dx) + sqf(dy) + bweight * sqf(db) + hweight * dh * dh + dweight * sqf(dd);
}
 
static GList *_brush_ramer_douglas_peucker(const float *point_buffer, int point_count,
                                           const float *payload_buffer, float epsilon2)
{
  GList *result_list = NULL;
 
  float dmax2 = 0.0f;
  int split_index = 0;
 
  for(int point_index = 1; point_index < point_count - 1; point_index++)
  {
    const float d2 = _brush_point_line_distance2(point_index, point_count,
                                                 point_buffer, payload_buffer);
    if(d2 > dmax2)
    {
      split_index = point_index;
      dmax2 = d2;
    }
  }
 
  if(dmax2 >= epsilon2)
  {
    GList *left_list = _brush_ramer_douglas_peucker(point_buffer, split_index + 1,
                                                    payload_buffer, epsilon2);
    GList *right_list = _brush_ramer_douglas_peucker(point_buffer + split_index * 2,
                                                     point_count - split_index,
                                                     payload_buffer + split_index * 4, epsilon2);
 
    // remove last element from left_list to avoid duplication at the split
    GList *end1 = g_list_last(left_list);
    dt_free(end1->data);
    left_list = g_list_delete_link(left_list, end1);
 
    result_list = g_list_concat(left_list, right_list);
  }
  else
  {
    dt_masks_node_brush_t *first_node = malloc(sizeof(dt_masks_node_brush_t));
    first_node->node[0] = point_buffer[0];
    first_node->node[1] = point_buffer[1];
    first_node->ctrl1[0] = first_node->ctrl1[1] = first_node->ctrl2[0] = first_node->ctrl2[1] = -1.0f;
    first_node->border[0] = first_node->border[1] = payload_buffer[0];
    first_node->fading = payload_buffer[1];
    first_node->density = payload_buffer[2];
    first_node->state = DT_MASKS_POINT_STATE_NORMAL;
    result_list = g_list_append(result_list, (gpointer)first_node);
 
    dt_masks_node_brush_t *last_node = malloc(sizeof(dt_masks_node_brush_t));
    last_node->node[0] = point_buffer[(point_count - 1) * 2];
    last_node->node[1] = point_buffer[(point_count - 1) * 2 + 1];
    last_node->ctrl1[0] = last_node->ctrl1[1] = last_node->ctrl2[0] = last_node->ctrl2[1] = -1.0f;
    last_node->border[0] = last_node->border[1] = payload_buffer[(point_count - 1) * 4];
    last_node->fading = payload_buffer[(point_count - 1) * 4 + 1];
    last_node->density = payload_buffer[(point_count - 1) * 4 + 2];
    last_node->state = DT_MASKS_POINT_STATE_NORMAL;
    result_list = g_list_append(result_list, (gpointer)last_node);
  }
 
  return result_list;
}
 
static void _brush_get_XY(float p0_x, float p0_y, float p1_x, float p1_y, float p2_x, float p2_y, float p3_x,
                          float p3_y, float t, float *out_x, float *out_y)
{
  const float ti = 1.0f - t;
  const float a = ti * ti * ti;
  const float b = 3.0f * t * ti * ti;
  const float c = 3.0f * sqf(t) * ti;
  const float d = t * t * t;
  *out_x = p0_x * a + p1_x * b + p2_x * c + p3_x * d;
  *out_y = p0_y * a + p1_y * b + p2_y * c + p3_y * d;
}
 
static gboolean _brush_border_get_XY(float p0_x, float p0_y, float p1_x, float p1_y, float p2_x, float p2_y,
                                     float p3_x, float p3_y, float t, float radius, float radius_rate,
                                     float *point_x, float *point_y, float *border_x, float *border_y)
{
  // we get the point
  _brush_get_XY(p0_x, p0_y, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y, t, point_x, point_y);
 
  // now we get derivative points
  const float ti = 1.0f - t;
  const float a = 3.0f * ti * ti;
  const float b = 3.0f * (ti * ti - 2.0f * t * ti);
  const float c = 3.0f * (2.0f * t * ti - t * t);
  const float d = 3.0f * sqf(t);
 
  /* not const: a degenerate first-order term is replaced by the limit direction below */
  float dx = -p0_x * a + p1_x * b + p2_x * c + p3_x * d;
  float dy = -p0_y * a + p1_y * b + p2_y * c + p3_y * d;
 
  /* A vanishing derivative does NOT mean the tangent is undefined -- it means the first-order
   * term is degenerate and the direction is given by the limit, i.e. by the first non-zero term.
   * That is exactly how a CUSP is stored: both of the node's handles sit on the node itself, so
   * the cubic's endpoint derivative 3*(p1 - p0) (or 3*(p3 - p2)) is zero there.
   *
   * Two separate defects lived in the three lines this replaces, and only the pair of them
   * explains issue #1313's follow-up ("the brush loses its radius in the direction of the point
   * of the cusp and so we have a sharp V hole").
   *
   * FIRST: the test was `== 0', and a vanishing derivative does not arrive as zero. These are
   * image pixels, so at the reported cusp -- where p2 == p3 bit for bit -- 3*(p3 - p2) evaluates
   * to 1.22e-4, because the products 3*1327.8497 are each rounded to float before the
   * subtraction. So the guard never fired at all. Execution fell through and NORMALISED that
   * residue: (1.22e-4, 0) normalises to (1, 0), and the border direction at the cusp became pure
   * rounding noise pointing along +x. The tell, once you know it, is a border sample sitting
   * exactly one radius due east of its node. The threshold below is therefore RELATIVE, scaled
   * to the control polygon because that is what the derivative scales with -- a genuine tangent
   * near the cusp is orders of magnitude larger (measured 1.06 at t = 0.999 against a 0.2 noise
   * floor), so the two separate cleanly and no real direction can be swallowed.
   *
   * SECOND: even when it did fire, returning NaN was the wrong answer. Every consumer falls back
   * to the previous border point, so the offset curve never rotated through the exterior angle
   * at the tip, the two sides of the joint coincided -- the gap between them measured (0.0, 0.0)
   * and the turn 0.0 degrees -- and the arc filler that exists to bridge exactly that wedge was
   * never triggered. Since a brush mask is the union of centreline->border spokes, the wedge at
   * the point of the cusp was simply never painted.
   *
   * For a cubic, if the first-order term vanishes the second-order one gives the limit
   * direction: (p2 - p0) at the start, (p3 - p1) at the end. If that is degenerate too, the
   * chord is the last honest answer. Only a curve collapsed to a single point has no direction
   * at all, and that one still reports NaN, because there is genuinely nothing to offset. */
  const float span = fmaxf(fmaxf(fabsf(p3_x - p0_x), fabsf(p3_y - p0_y)),
                           fmaxf(fabsf(p2_x - p1_x), fabsf(p2_y - p1_y)));
  const float degenerate = fmaxf(span, 1.0f) * 1e-3f;
 
  if(fabsf(dx) < degenerate && fabsf(dy) < degenerate)
  {
    if(t < 0.5f) { dx = p2_x - p0_x; dy = p2_y - p0_y; }
    else         { dx = p3_x - p1_x; dy = p3_y - p1_y; }
 
    if(fabsf(dx) < degenerate && fabsf(dy) < degenerate) { dx = p3_x - p0_x; dy = p3_y - p0_y; }
 
    if(dx == 0.0f && dy == 0.0f) return FALSE;   // a single point: no direction to offset along
 
    /* a limit direction has a direction and no speed, so no rate can be taken against it */
    radius_rate = 0.0f;
  }
 
  /* on the envelope of the discs, not on the normal: see dt_masks_outline_envelope_offset() */
  const float centre[2] = { *point_x, *point_y };
  float border[2];
  dt_masks_outline_envelope_offset(centre, dx, dy, radius, radius_rate, border);
  *border_x = border[0];
  *border_y = border[1];
  return TRUE;
}
 
/* The radius along a segment eases from one node's to the other's, r1 + (r2 - r1) * t^2 (3 - 2t),
 * and its rate by t is what the envelope needs: (r2 - r1) * 6 t (1 - t), zero at both ends, so a
 * segment's end samples stay on the normal and the caps and joint arcs built from them are
 * unchanged. */
static inline float _brush_radius_at(const float r1, const float r2, const double t)
{
  return r1 + (r2 - r1) * t * t * (3.0 - 2.0 * t);
}
 
static inline float _brush_radius_rate_at(const float r1, const float r2, const double t)
{
  return (r2 - r1) * 6.0 * t * (1.0 - t);
}
 
static void _brush_ctrl2_to_handle(float point_x, float point_y, float ctrl_x, float ctrl_y,
                                   float *handle_x, float *handle_y, gboolean clockwise)
{
  if(clockwise)
  {
    *handle_x = point_x + ctrl_y - point_y;
    *handle_y = point_y + point_x - ctrl_x;
  }
  else
  {
    *handle_x = point_x - ctrl_y + point_y;
    *handle_y = point_y - point_x + ctrl_x;
  }
}
 
static gboolean _brush_get_border_handle_resampled(const dt_masks_form_gui_points_t *gui_points, int node_count,
                                                   int node_index, float *handle_x, float *handle_y)
{
  if(IS_NULL_PTR(gui_points) || node_count <= 0 || node_index < 0 || node_index >= node_count) return FALSE;
 
  const int start = node_count * 3;
  const int max_points = MIN(gui_points->points_count, gui_points->border_count);
  if(max_points <= start) return FALSE;
 
  const float node_x = gui_points->points[node_index * 6 + 2];
  const float node_y = gui_points->points[node_index * 6 + 3];
 
  float best_dist2 = FLT_MAX;
  int best_idx = -1;
 
  for(int i = start; i < max_points; i++)
  {
    /* Skip an index inside an EXCLUDED span, because the border sample there is one the outline
     * does not show -- the offset curve doubles back on itself, and a node can sit opposite such
     * a span; a cusp does. This used to be a NaN test against the buffer, back when the excluded
     * samples were blanked in place, and it cost the node its handle outright when it fired: no
     * dash drawn, and no hover or drag either, since both interactions resolve through here.
     * Asking the list instead both keeps the handle and stops this function caring how the
     * drawer marks its exclusions. */
    if(dt_masks_skip_contains(gui_points->border_skips, gui_points->border_skip_count, i)) continue;
 
    const float px = gui_points->points[i * 2];
    const float py = gui_points->points[i * 2 + 1];
    const float dx = node_x - px;
    const float dy = node_y - py;
    const float dist2 = dx * dx + dy * dy;
    if(dist2 < best_dist2)
    {
      best_dist2 = dist2;
      best_idx = i;
    }
  }
 
  if(best_idx < 0) return FALSE;
 
  *handle_x = gui_points->border[best_idx * 2];
  *handle_y = gui_points->border[best_idx * 2 + 1];
  return TRUE;
}
 
static gboolean _brush_get_border_handle_mirrored(const dt_masks_form_gui_points_t *gui_points, int node_count,
                                                  int node_index, float *handle_x, float *handle_y)
{
  float resampled_x = 0.0f;
  float resampled_y = 0.0f;
  if(!_brush_get_border_handle_resampled(gui_points, node_count, node_index, &resampled_x, &resampled_y)) return FALSE;
 
  const float node_x = gui_points->points[node_index * 6 + 2];
  const float node_y = gui_points->points[node_index * 6 + 3];
 
  *handle_x = node_x - (resampled_x - node_x);
  *handle_y = node_y - (resampled_y - node_y);
  return TRUE;
}
 
static void _brush_handle_to_ctrl(float ptx, float pty, float fx, float fy,
                                   float *ctrl1x, float *ctrl1y,
                                   float *ctrl2x, float *ctrl2y, gboolean clockwise)
{
  if(clockwise)
  {
    *ctrl2x = ptx + pty - fy;
    *ctrl2y = pty + fx - ptx;
    *ctrl1x = ptx - pty + fy;
    *ctrl1y = pty - fx + ptx;
  }
  else
  {
    *ctrl1x = ptx + pty - fy;
    *ctrl1y = pty + fx - ptx;
    *ctrl2x = ptx - pty + fy;
    *ctrl2y = pty - fx + ptx;
  }
}
 
static void _brush_catmull_to_bezier(float x1, float y1, float x2, float y2, float x3, float y3, float x4,
                                     float y4, float *bezier1_x, float *bezier1_y,
                                     float *bezier2_x, float *bezier2_y)
{
  *bezier1_x = (-x1 + 6 * x2 + x3) / 6;
  *bezier1_y = (-y1 + 6 * y2 + y3) / 6;
  *bezier2_x = (x2 + 6 * x3 - x4) / 6;
  *bezier2_y = (y2 + 6 * y3 - y4) / 6;
}
 
static void _brush_init_ctrl_points(dt_masks_form_t *mask_form)
{
  if(IS_NULL_PTR(mask_form) || IS_NULL_PTR(mask_form->points)) return;
  // if we have less than 2 points, what to do ??
  if(g_list_shorter_than(mask_form->points, 2)) return;
 
  // we need extra points to deal with curve ends
  dt_masks_node_brush_t start_point[2], end_point[2];
 
  for(GList *form_points = mask_form->points; form_points; form_points = g_list_next(form_points))
  {
    dt_masks_node_brush_t *point3 = (dt_masks_node_brush_t *)form_points->data;
    if(IS_NULL_PTR(point3)) continue;
    // if the point has not been set manually, we redefine it
    if(point3->state == DT_MASKS_POINT_STATE_NORMAL)
    {
      // we want to get point-2, point-1, point+1, point+2
      GList *const prev = g_list_previous(form_points);             // point-1
      GList *const prevprev = prev ? g_list_previous(prev) : NULL;  // point-2
      GList *const next = g_list_next(form_points);                 // point+1
      GList *const nextnext = next ? g_list_next(next) : NULL;      // point+2
      dt_masks_node_brush_t *point1 = prevprev ? prevprev->data : NULL;
      dt_masks_node_brush_t *point2 = prev ? prev->data : NULL;
      dt_masks_node_brush_t *point4 = next ? next->data : NULL;
      dt_masks_node_brush_t *point5 = nextnext ? nextnext->data : NULL;
 
      // deal with end points: make both extending points mirror their neighborhood
      if(IS_NULL_PTR(point1) && IS_NULL_PTR(point2))
      {
        start_point[0].node[0] = start_point[1].node[0] = 2 * point3->node[0] - point4->node[0];
        start_point[0].node[1] = start_point[1].node[1] = 2 * point3->node[1] - point4->node[1];
        point1 = &(start_point[0]);
        point2 = &(start_point[1]);
      }
      else if(IS_NULL_PTR(point1))
      {
        start_point[0].node[0] = 2 * point2->node[0] - point3->node[0];
        start_point[0].node[1] = 2 * point2->node[1] - point3->node[1];
        point1 = &(start_point[0]);
      }
 
      if(IS_NULL_PTR(point4) && IS_NULL_PTR(point5))
      {
        end_point[0].node[0] = end_point[1].node[0] = 2 * point3->node[0] - point2->node[0];
        end_point[0].node[1] = end_point[1].node[1] = 2 * point3->node[1] - point2->node[1];
        point4 = &(end_point[0]);
        point5 = &(end_point[1]);
      }
      else if(IS_NULL_PTR(point5))
      {
        end_point[0].node[0] = 2 * point4->node[0] - point3->node[0];
        end_point[0].node[1] = 2 * point4->node[1] - point3->node[1];
        point5 = &(end_point[0]);
      }
 
 
      float bx1 = 0.0f, by1 = 0.0f, bx2 = 0.0f, by2 = 0.0f;
      _brush_catmull_to_bezier(point1->node[0], point1->node[1], point2->node[0], point2->node[1],
                               point3->node[0], point3->node[1], point4->node[0], point4->node[1],
                               &bx1, &by1, &bx2, &by2);
      if(point2->ctrl2[0] == -1.0) point2->ctrl2[0] = bx1;
      if(point2->ctrl2[1] == -1.0) point2->ctrl2[1] = by1;
      point3->ctrl1[0] = bx2;
      point3->ctrl1[1] = by2;
      _brush_catmull_to_bezier(point2->node[0], point2->node[1], point3->node[0], point3->node[1],
                               point4->node[0], point4->node[1], point5->node[0], point5->node[1],
                               &bx1, &by1, &bx2, &by2);
      if(point4->ctrl1[0] == -1.0) point4->ctrl1[0] = bx2;
      if(point4->ctrl1[1] == -1.0) point4->ctrl1[1] = by2;
      point3->ctrl2[0] = bx1;
      point3->ctrl2[1] = by1;
    }
  }
}
 
 
static void _brush_points_recurs_border_gaps(float *cmax, float *bmin, float *bmax,
                                             dt_masks_dynbuf_t *dpoints, dt_masks_dynbuf_t *dborder,
                                             gboolean clockwise, const int step)
{
  // we want to find the start and end angles
  float a1 = atan2f(bmin[1] - cmax[1], bmin[0] - cmax[0]);
  float a2 = atan2f(bmax[1] - cmax[1], bmax[0] - cmax[0]);
 
  if(a1 == a2) return;
 
  // we have to be sure that we turn in the correct direction
  if(a2 < a1 && clockwise)
  {
    a2 += 2.0f * M_PI;
  }
  if(a2 > a1 && !clockwise)
  {
    a1 += 2.0f * M_PI;
  }
 
  // we determine start and end radius too
  float r1 = dt_fast_hypotf(bmin[1] - cmax[1], bmin[0] - cmax[0]);
  float r2 = dt_fast_hypotf(bmax[1] - cmax[1], bmax[0] - cmax[0]);
 
  // and the max length of the circle arc, in samples
  const int l = fabsf(a2 - a1) * fmaxf(r1, r2) / (float)step;
  if(l < 2) return;
 
  // and now we add the points
  const float incra = (a2 - a1) / l;
  const float incrr = (r2 - r1) / l;
 
  // Use incremental rotation to avoid repeated cosf/sinf calls
  const float cos_incra = cosf(incra);
  const float sin_incra = sinf(incra);
  float rr = r1 + incrr;
  float cos_aa = cosf(a1 + incra);
  float sin_aa = sinf(a1 + incra);
 
  // allocate entries in the dynbufs
  float *dpoints_ptr = dt_masks_dynbuf_reserve_n(dpoints, 2*(l-1));
  float *dborder_ptr = dt_masks_dynbuf_reserve_n(dborder, 2*(l-1));
  // and fill them in: the same center pos for each point in dpoints, and the corresponding border point at
  //  successive angular positions for dborder
  if (!IS_NULL_PTR(dpoints_ptr) && !IS_NULL_PTR(dborder_ptr))
  {
    for(int i = 1; i < l; i++)
    {
      *dpoints_ptr++ = cmax[0];
      *dpoints_ptr++ = cmax[1];
      *dborder_ptr++ = cmax[0] + rr * cos_aa;
      *dborder_ptr++ = cmax[1] + rr * sin_aa;
      
      // Incremental rotation: rotate by incra using addition formulas
      const float new_cos = cos_aa * cos_incra - sin_aa * sin_incra;
      const float new_sin = sin_aa * cos_incra + cos_aa * sin_incra;
      cos_aa = new_cos;
      sin_aa = new_sin;
      rr += incrr;
    }
  }
}
 
static void _brush_points_recurs_border_small_gaps(float *cmax, float *bmin, float *bmax,
                                                   dt_masks_dynbuf_t *dpoints, dt_masks_dynbuf_t *dborder,
                                                   const int step)
{
  // we want to find the start and end angles
  const float a1 = fmodf(atan2f(bmin[1] - cmax[1], bmin[0] - cmax[0]) + 2.0f * M_PI, 2.0f * M_PI);
  const float a2 = fmodf(atan2f(bmax[1] - cmax[1], bmax[0] - cmax[0]) + 2.0f * M_PI, 2.0f * M_PI);
 
  if(a1 == a2) return;
 
  // we determine start and end radius too
  const float r1 = dt_fast_hypotf(bmin[1] - cmax[1], bmin[0] - cmax[0]);
  const float r2 = dt_fast_hypotf(bmax[1] - cmax[1], bmax[0] - cmax[0]);
 
  // we close the gap in the shortest direction
  float delta = a2 - a1;
  if(fabsf(delta) > M_PI) delta = delta - copysignf(2.0f * M_PI, delta);
 
  // get the max length of the circle arc, in samples
  const int l = fabsf(delta) * fmaxf(r1, r2) / (float)step;
  if(l < 2) return;
 
  // and now we add the points
  const float incra = delta / l;
  const float incrr = (r2 - r1) / l;
  
  // Use incremental rotation to avoid repeated cosf/sinf calls
  const float cos_incra = cosf(incra);
  const float sin_incra = sinf(incra);
  float rr = r1 + incrr;
  float cos_aa = cosf(a1 + incra);
  float sin_aa = sinf(a1 + incra);
  
  // allocate entries in the dynbufs
  float *dpoints_ptr = dt_masks_dynbuf_reserve_n(dpoints, 2*(l-1));
  float *dborder_ptr = dt_masks_dynbuf_reserve_n(dborder, 2*(l-1));
  // and fill them in: the same center pos for each point in dpoints, and the corresponding border point at
  //  successive angular positions for dborder
  if (!IS_NULL_PTR(dpoints_ptr) && !IS_NULL_PTR(dborder_ptr))
  {
    for(int i = 1; i < l; i++)
    {
      *dpoints_ptr++ = cmax[0];
      *dpoints_ptr++ = cmax[1];
      *dborder_ptr++ = cmax[0] + rr * cos_aa;
      *dborder_ptr++ = cmax[1] + rr * sin_aa;
      
      // Incremental rotation: rotate by incra using addition formulas
      const float new_cos = cos_aa * cos_incra - sin_aa * sin_incra;
      const float new_sin = sin_aa * cos_incra + cos_aa * sin_incra;
      cos_aa = new_cos;
      sin_aa = new_sin;
      rr += incrr;
    }
  }
}
 
 
static void _brush_points_stamp(const float *const centre, const float *const from_border, const float radius,
                                dt_masks_dynbuf_t *dpoints, dt_masks_dynbuf_t *dborder, const int step)
{
  const float a1 = atan2f(from_border[1] - centre[1], from_border[0] - centre[0]);
 
  // determine the max length of the circle arc, in samples
  const int l = 2.0f * M_PI * radius / (float)step;
  if(l < 2) return;
 
  // and now we add the points
  const float incra = 2.0f * M_PI / l;
  float aa = a1 + incra;
  // allocate entries in the dynbuf
  float *dpoints_ptr = dt_masks_dynbuf_reserve_n(dpoints, 2*(l-1));
  float *dborder_ptr = dt_masks_dynbuf_reserve_n(dborder, 2*(l-1));
  // and fill them in: the same center pos for each point in dpoints, and the corresponding border point at
  //  successive angular positions for dborder
  if (!IS_NULL_PTR(dpoints_ptr) && !IS_NULL_PTR(dborder_ptr))
  {
    for(int i = 0; i < l; i++)
    {
      *dpoints_ptr++ = centre[0];
      *dpoints_ptr++ = centre[1];
      *dborder_ptr++ = centre[0] + radius * cosf(aa);
      *dborder_ptr++ = centre[1] + radius * sinf(aa);
      aa += incra;
    }
  }
}
 
static inline gboolean _is_within_pxl_threshold(const float *const min, const float *const max, const int pixel_threshold)
{
  return abs((int)min[0] - (int)max[0]) < pixel_threshold && 
         abs((int)min[1] - (int)max[1]) < pixel_threshold;
}
 
static inline void _brush_payload_sync(dt_masks_dynbuf_t *dpayload, dt_masks_dynbuf_t *dpoints,
                                       const float v0, const float v1)
{
  size_t payload_pos = dt_masks_dynbuf_position(dpayload);
  const size_t target_pos = dt_masks_dynbuf_position(dpoints);
  while(payload_pos < target_pos)
  {
    dt_masks_dynbuf_add_2(dpayload, v0, v1);
    payload_pos += 2;
  }
}
 
/* Is the span [tmin, tmax] fine enough to write as one sample: its ends within the pixel
 * threshold of each other, on the centreline and -- when a border is being built, @p border_min
 * non-NULL -- on the border too. */
static inline gboolean _brush_span_is_leaf(const double tmin, const double tmax, const float *const points_min,
                                    const float *const points_max, const float *const border_min,
                                    const float *const border_max, const int pixel_threshold)
{
  if(tmax - tmin < 0.0001f) return TRUE;
  if(!_is_within_pxl_threshold(points_min, points_max, pixel_threshold)) return FALSE;
  if(IS_NULL_PTR(border_min)) return TRUE;
  return _is_within_pxl_threshold(border_min, border_max, pixel_threshold);
}
 
/* Give a leaf's far end a border when the span's ends did not both come with one: borrow
 * the near end's; and if neither end has a direction, a spoke of the right LENGTH along the
 * chord's normal.
 *
 * What used to happen in that last case is the whole of issue #1360: border_max was the
 * caller's zero-initialised scratch, and (0, 0) -- the image origin -- went into the buffer
 * as if it were geometry. A spoke of the right length in some direction is always a valid
 * piece of the disc union; a spoke to the corner of the frame never is. The walk only hands
 * the recursion segments that have a direction at an end, so the case is unreachable in
 * practice; it is kept safe rather than asserted. */
static inline void _brush_leaf_borrow_border(float *const border_min, float *const border_max,
                                      const gboolean have_min, const gboolean have_max,
                                      const float *const centre, const float *const chord, const float radius)
{
  if(have_max)
  {
    /* only have_max is reported upward, so a borrowed min needs no flag */
    if(!have_min)
    {
      border_min[0] = border_max[0];
      border_min[1] = border_max[1];
    }
    return;
  }
  if(have_min)
  {
    border_max[0] = border_min[0];
    border_max[1] = border_min[1];
    return;
  }
  dt_masks_outline_offset_along(centre, chord[1], -chord[0], radius, border_max);
}
 
/* The frame the walk works in: the image size the normalised node coordinates scale to, and
 * the shift that moves a clone source's outline onto its target. */
typedef struct _brush_frame_t
{
  float iwd;
  float iht;
  float dx;
  float dy;
} _brush_frame_t;
 
/* THE WALK.
 *
 * A brush is the union of a disc of the local radius over every point of its centreline, and
 * the rasteriser paints that union as spokes: from every centreline sample out to its border
 * sample, on both sides. So the centreline is walked twice, forward with the border on the
 * right and backward with the border on the right again -- the other side -- and the two
 * sides are joined by a cap at each end. Where the direction, the radius or the payload jumps
 * at a node, the spokes of the two segments meeting there leave a wedge; a disc or an arc,
 * centred on that node at that node's radius, fills it.
 *
 * Everything a joint or a cap needs is taken from the two segment END SAMPLES that meet
 * there, and from the node data. Nothing is read back out of the buffers. The previous walk
 * took "the last centreline sample and the last border sample written" as the centre and
 * radius of every cap, arc and stamp, on the assumption that they belonged to one spoke; a
 * degenerate segment broke that assumption once and the damage compounded through every
 * later joint of the stroke (issue #1360: a circle 2058 px across, centred on the stroke,
 * grown from a border sample that was the image origin).
 *
 * A DEGENERATE segment -- its four control points one point, which is what a pen resting
 * under rising pressure produces -- has no direction and so no spokes, and contributes
 * nothing: its disc is the cap of whichever neighbour has a direction. The walk skips it and
 * joins the segments either side of it as if it were not there, which for the disc union is
 * exactly right. */
typedef struct _brush_walk_t
{
  dt_masks_node_brush_t **nodes;
  int node_count;
  _brush_frame_t frame;
  int pixel_threshold;
  /* Image pixels between consecutive samples of an arc or a stamp. The GUI's outline takes the
   * density it is shown at, like its curves; the pipe keeps one per pixel whatever spoke
   * budget it was given, so its raster does not change under a preference. */
  int arc_step;
  dt_masks_dynbuf_t *dpoints;
  dt_masks_dynbuf_t *dborder;   /* NULL when no border is wanted */
  dt_masks_dynbuf_t *dpayload;  /* NULL when no payload is wanted */
} _brush_walk_t;
 
/* One span [tmin, tmax] of a segment and what is known at its ends: the spine and border
 * samples there, whether each end was evaluated already, and whether a border came with it.
 * Those flags used to be read out of the arrays as NaN -- "not computed" and "no border"
 * sharing one representation with each other and with real geometry. Which of the three a NaN
 * meant depended on where you were standing, and the arrays are the same ones that end up in
 * the outline. A leaf always writes a border now (see _brush_leaf_borrow_border()). */
typedef struct _brush_span_t
{
  double tmin;
  double tmax;
  float *points_min;
  float *points_max;
  float *border_min;
  float *border_max;
  gboolean have_min;
  gboolean have_max;
  gboolean have_border_min;
  gboolean have_border_max;
} _brush_span_t;
 
/* The sample a span's far end resolved to: the next span's near end, and the segment's end
 * sample for the walk. have_border is TRUE whenever a border is being built at all. */
typedef struct _brush_sample_t
{
  float point[2];
  float border[2];
  float payload[2];
  gboolean have_border;
} _brush_sample_t;
 
static void _brush_points_recurs(const float *const p1, const float *const p2, const _brush_span_t *const span,
                                 const _brush_walk_t *const w, _brush_sample_t *const out)
{
  dt_masks_dynbuf_t *const dpoints = w->dpoints;
  dt_masks_dynbuf_t *const dborder = w->dborder;
  dt_masks_dynbuf_t *const dpayload = w->dpayload;
  const gboolean withborder = (!IS_NULL_PTR(dborder));
  float *const points_min = span->points_min;
  float *const points_max = span->points_max;
  float *const border_min = span->border_min;
  float *const border_max = span->border_max;
  gboolean have_border_min = span->have_border_min;
  gboolean have_border_max = span->have_border_max;
 
  // we calculate points if needed
  if(!span->have_min)
    have_border_min = _brush_border_get_XY(p1[0], p1[1], p1[2], p1[3], p2[2], p2[3], p2[0], p2[1], span->tmin,
                                           _brush_radius_at(p1[4], p2[4], span->tmin),
                                           _brush_radius_rate_at(p1[4], p2[4], span->tmin), points_min,
                                           points_min + 1, border_min, border_min + 1);
  if(!span->have_max)
    have_border_max = _brush_border_get_XY(p1[0], p1[1], p1[2], p1[3], p2[2], p2[3], p2[0], p2[1], span->tmax,
                                           _brush_radius_at(p1[4], p2[4], span->tmax),
                                           _brush_radius_rate_at(p1[4], p2[4], span->tmax), points_max,
                                           points_max + 1, border_max, border_max + 1);
 
  if(!_brush_span_is_leaf(span->tmin, span->tmax, points_min, points_max, withborder ? border_min : NULL,
                          border_max, w->pixel_threshold))
  {
    // we split in two part
    const double tx = (span->tmin + span->tmax) / 2.0;
    float c[2] = { 0.0f, 0.0f };
    float b[2] = { 0.0f, 0.0f };
    _brush_sample_t mid = { 0 };
    /* the left half inherits our min end, now evaluated, and computes the midpoint; the right
     * half is then handed that midpoint already evaluated, and inherits our max end */
    const _brush_span_t left = { span->tmin, tx, points_min, c, border_min, b, TRUE, FALSE, have_border_min, FALSE };
    _brush_points_recurs(p1, p2, &left, w, &mid);
    const _brush_span_t right
        = { tx, span->tmax, mid.point, points_max, mid.border, border_max, TRUE, TRUE, TRUE, have_border_max };
    _brush_points_recurs(p1, p2, &right, w, out);
    return;
  }
 
  // the leaf: one sample, at the far end of the span
  out->point[0] = points_max[0];
  out->point[1] = points_max[1];
  out->have_border = FALSE;
  dt_masks_dynbuf_add_2(dpoints, out->point[0], out->point[1]);
 
  if(withborder)
  {
    const float radius = _brush_radius_at(p1[4], p2[4], span->tmax);
    const float chord[2] = { p2[0] - p1[0], p2[1] - p1[1] };
    _brush_leaf_borrow_border(border_min, border_max, have_border_min, have_border_max, points_max, chord, radius);
 
    // we check gaps in the border (sharp edges), at the density the arc will be sampled at
    const int gap = 2 * w->arc_step;
    if(abs((int)border_max[0] - (int)border_min[0]) > gap || abs((int)border_max[1] - (int)border_min[1]) > gap)
      _brush_points_recurs_border_small_gaps(points_max, border_min, border_max, dpoints, dborder, w->arc_step);
 
    out->border[0] = border_max[0];
    out->border[1] = border_max[1];
    out->have_border = TRUE;
    dt_masks_dynbuf_add_2(dborder, out->border[0], out->border[1]);
  }
 
  if(!IS_NULL_PTR(dpayload))
  {
    out->payload[0] = p1[5] + span->tmax * (p2[5] - p1[5]);
    out->payload[1] = p1[6] + span->tmax * (p2[6] - p1[6]);
    _brush_payload_sync(dpayload, dpoints, out->payload[0], out->payload[1]);
  }
}
 
/* The two ends of one segment of the walk, in image pixels: node, the control point that
 * faces the other end, radius, fading, density. Travelling forward the segment leaves node
 * `from` through its ctrl2 and enters `to` through its ctrl1; backward it is the other pair.
 * The radii are read the way the walk always has: the start of a segment carries its node's
 * border[1] and the end its node's border[0]. Every writer in this file sets the two together,
 * so they agree; the walk takes the larger wherever it has to choose one for a node. */
static void _brush_segment_load(const dt_masks_node_brush_t *const from, const dt_masks_node_brush_t *const to,
                                const gboolean forward, const _brush_frame_t *const frame, float p1[7],
                                float p2[7])
{
  const float *const from_ctrl = forward ? from->ctrl2 : from->ctrl1;
  const float *const to_ctrl = forward ? to->ctrl1 : to->ctrl2;
  const float radius_scale = MIN(frame->iwd, frame->iht);
 
  p1[0] = from->node[0] * frame->iwd - frame->dx;
  p1[1] = from->node[1] * frame->iht - frame->dy;
  p1[2] = from_ctrl[0] * frame->iwd - frame->dx;
  p1[3] = from_ctrl[1] * frame->iht - frame->dy;
  p1[4] = from->border[1] * radius_scale;
  p1[5] = from->fading;
  p1[6] = from->density;
 
  p2[0] = to->node[0] * frame->iwd - frame->dx;
  p2[1] = to->node[1] * frame->iht - frame->dy;
  p2[2] = to_ctrl[0] * frame->iwd - frame->dx;
  p2[3] = to_ctrl[1] * frame->iht - frame->dy;
  p2[4] = to->border[0] * radius_scale;
  p2[5] = to->fading;
  p2[6] = to->density;
}
 
/* The arc that bridges a joint, the short way round; at a cusp the pass's rotation decides
 * (see dt_masks_outline_short_way()). The filler is the brush's own. */
static void _brush_joint_arc(const float *const centre, const float *const from, const float *const to,
                             const gboolean forward, dt_masks_dynbuf_t *dpoints, dt_masks_dynbuf_t *dborder,
                             const int step)
{
  const gboolean clockwise = dt_masks_outline_short_way(centre, from, to, forward);
  float f[2] = { from[0], from[1] };
  float t[2] = { to[0], to[1] };
  float c[2] = { centre[0], centre[1] };
  _brush_points_recurs_border_gaps(c, f, t, dpoints, dborder, clockwise, step);
}
 
/* The walk at the node the next segment starts from: the end sample of the previous
 * non-degenerate segment of this pass. */
typedef struct _brush_walk_state_t
{
  gboolean have_prev;
  float c[2];
  float b[2];
  float r;
  float payload[2];
} _brush_walk_state_t;
 
static inline void _brush_walk_sync_payload(const _brush_walk_t *const w, const float *const payload)
{
  if(!IS_NULL_PTR(w->dpayload)) _brush_payload_sync(w->dpayload, w->dpoints, payload[0], payload[1]);
}
 
/* What the node a segment starts from needs, once both its segments are known: a disc where
 * the stroke changes attribute, an arc where it changes direction. @p p1/@p p2 are the segment
 * about to be walked, @p c0/@p b0 its start sample. */
static void _brush_walk_node(const _brush_walk_t *const w, const _brush_walk_state_t *const s,
                             const float *const p1, const float *const p2, const float *const c0,
                             const float *const b0, const gboolean forward)
{
  if(IS_NULL_PTR(w->dborder)) return;
 
  /* The stroke changes attribute along this segment: the node it starts from gets a full disc
   * at the attribute it leaves behind, so an opacity or size step reads as a round junction
   * and not as a seam across the stroke. Same triggers as ever; the radius is the larger of the
   * two the node carries, which is the disc the union actually has there. */
  const gboolean payload_step = (fabsf(p1[5] - p2[5]) > 0.05f || fabsf(p1[6] - p2[6]) > 0.05f);
  const gboolean radius_step = (fabsf(p1[4] - p2[4]) > 0.0001f || fabsf(s->r - p1[4]) > 0.0001f);
  if(payload_step || radius_step)
  {
    _brush_points_stamp(s->c, s->b, fmaxf(s->r, p1[4]), w->dpoints, w->dborder, w->arc_step);
    _brush_walk_sync_payload(w, s->payload);
  }
 
  /* The border of the previous segment ends on one side of the joint and this one's starts on
   * the other; this arc bridges the wedge between them, centred on the node. Without it the
   * rasteriser has no spokes across the joint and the stroke loses its radius toward the node
   * -- at a cusp that is a sharp V hole in the exported mask (issue #1313's follow-up). On the
   * concave side of a joint the short sweep runs through the inside of the stroke, which
   * paints nothing new; those samples are inside the disc union, so the boundary pass hides
   * them from the outline. */
  if(fabsf(b0[0] - s->b[0]) > 1.0f || fabsf(b0[1] - s->b[1]) > 1.0f)
  {
    _brush_joint_arc(c0, s->b, b0, forward, w->dpoints, w->dborder, w->arc_step);
    _brush_walk_sync_payload(w, s->payload);
  }
}
 
/* One segment of one pass: the node work at its start, then every sample within a pixel of
 * the last and its border. Returns FALSE for a degenerate segment, which contributes nothing. */
static gboolean _brush_walk_segment(const _brush_walk_t *const w, _brush_walk_state_t *const s, const int k,
                                    const int k1, const gboolean forward)
{
  float p1[7];
  float p2[7];
  _brush_segment_load(w->nodes[k], w->nodes[k1], forward, &w->frame, p1, p2);
 
  /* the segment's own end samples; a segment with a direction at neither end is a point */
  float c0[2];
  float b0[2];
  float c1[2];
  float b1[2];
  const gboolean have_b0 = _brush_border_get_XY(p1[0], p1[1], p1[2], p1[3], p2[2], p2[3], p2[0], p2[1], 0.0f,
                                                p1[4], 0.0f, c0, c0 + 1, b0, b0 + 1);
  const gboolean have_b1 = _brush_border_get_XY(p1[0], p1[1], p1[2], p1[3], p2[2], p2[3], p2[0], p2[1], 1.0f,
                                                p2[4], 0.0f, c1, c1 + 1, b1, b1 + 1);
  if(!have_b0 && !have_b1) return FALSE;
  if(!have_b0) dt_masks_outline_offset_along(c0, b1[0] - c1[0], b1[1] - c1[1], p1[4], b0);
  if(!have_b1) dt_masks_outline_offset_along(c1, b0[0] - c0[0], b0[1] - c0[1], p2[4], b1);
 
  if(s->have_prev) _brush_walk_node(w, s, p1, p2, c0, b0, forward);
 
  float bmin[2] = { b0[0], b0[1] };
  float bmax[2] = { b1[0], b1[1] };
  float cmin[2] = { c0[0], c0[1] };
  float cmax[2] = { c1[0], c1[1] };
  const _brush_span_t span = { 0.0, 1.0, cmin, cmax, bmin, bmax, TRUE, TRUE, TRUE, TRUE };
  _brush_sample_t end = { 0 };
  _brush_points_recurs(p1, p2, &span, w, &end);
 
  dt_masks_dynbuf_add_2(w->dpoints, end.point[0], end.point[1]);
  if(!IS_NULL_PTR(w->dpayload)) dt_masks_dynbuf_add_2(w->dpayload, end.payload[0], end.payload[1]);
  if(!IS_NULL_PTR(w->dborder))
  {
    if(!end.have_border)
      dt_masks_outline_offset_along(end.point, b1[0] - c1[0], b1[1] - c1[1], p2[4], end.border);
    dt_masks_dynbuf_add_2(w->dborder, end.border[0], end.border[1]);
  }
 
  s->c[0] = end.point[0];
  s->c[1] = end.point[1];
  s->b[0] = end.border[0];
  s->b[1] = end.border[1];
  s->r = p2[4];
 
  s->payload[0] = end.payload[0];
  s->payload[1] = end.payload[1];
  s->have_prev = TRUE;
  return TRUE;
}
 
/* The cap: from the last border sample of a pass around the outside of the end node to the
 * opposite side, where the other pass takes over. */
static void _brush_walk_cap(const _brush_walk_t *const w, const _brush_walk_state_t *const s)
{
  if(IS_NULL_PTR(w->dborder)) return;
  float centre[2] = { s->c[0], s->c[1] };
  float from[2] = { s->b[0], s->b[1] };
  float opposite[2] = { 2.0f * s->c[0] - s->b[0], 2.0f * s->c[1] - s->b[1] };
  _brush_points_recurs_border_gaps(centre, from, opposite, w->dpoints, w->dborder, TRUE, w->arc_step);
  _brush_walk_sync_payload(w, s->payload);
}
 
/* One pass over the segments, forward or backward, with the border on the right of travel.
 * Returns whether any segment had a direction, i.e. whether anything at all was walked. */
static gboolean _brush_walk_pass(const _brush_walk_t *const w, const gboolean forward)
{
  _brush_walk_state_t s = { 0 };
  const int last = w->node_count - 1;
  for(int step = 0; step < last; step++)
  {
    const int k = forward ? step : last - step;
    const int k1 = forward ? step + 1 : last - 1 - step;
    _brush_walk_segment(w, &s, k, k1, forward);
  }
  if(s.have_prev) _brush_walk_cap(w, &s);
  return s.have_prev;
}
 
/* Every segment is a point: the whole brush is one dab. It still has a radius and a payload,
 * so it is still a disc; stamp it once, from the first node. */
static void _brush_walk_single_dab(const _brush_walk_t *const w)
{
  const dt_masks_node_brush_t *const n0 = w->nodes[0];
  const float centre[2] = { n0->node[0] * w->frame.iwd - w->frame.dx, n0->node[1] * w->frame.iht - w->frame.dy };
  const float radius = fmaxf(n0->border[0], n0->border[1]) * MIN(w->frame.iwd, w->frame.iht);
  const float from[2] = { centre[0] + radius, centre[1] };
  dt_masks_dynbuf_add_2(w->dpoints, centre[0], centre[1]);
  if(!IS_NULL_PTR(w->dborder))
  {
    dt_masks_dynbuf_add_2(w->dborder, from[0], from[1]);
    _brush_points_stamp(centre, from, radius, w->dpoints, w->dborder, w->arc_step);
  }
  const float payload[2] = { n0->fading, n0->density };
  _brush_walk_sync_payload(w, payload);
}
 
/* The three sample buffers of a walk: points always, border and payload only when the caller
 * asked for them. All-or-nothing: on failure nothing is left allocated. */
static gboolean _brush_bufs_alloc(const gboolean want_border, const gboolean want_payload,
                                  dt_masks_dynbuf_t **dpoints, dt_masks_dynbuf_t **dborder,
                                  dt_masks_dynbuf_t **dpayload)
{
  *dpoints = dt_masks_dynbuf_init(1000000, "brush dpoints");
  *dborder = want_border ? dt_masks_dynbuf_init(1000000, "brush dborder") : NULL;
  *dpayload = want_payload ? dt_masks_dynbuf_init(1000000, "brush dpayload") : NULL;
  if(!IS_NULL_PTR(*dpoints) && (!want_border || !IS_NULL_PTR(*dborder))
     && (!want_payload || !IS_NULL_PTR(*dpayload)))
    return TRUE;
  dt_masks_dynbuf_free(*dpoints);
  dt_masks_dynbuf_free(*dborder);
  dt_masks_dynbuf_free(*dpayload);
  *dpoints = NULL;
  *dborder = NULL;
  *dpayload = NULL;
  return FALSE;
}
 
/* A harvested outline, the two arrays a transform acts on. */
typedef struct _brush_outline_t
{
  float *points;
  int point_count;
  float *border;   /* NULL when no border was built */
  int border_count;
} _brush_outline_t;
 
/* Transform the harvested outline with the pipeline's distortions. Two cases: the source of a
 * clone, which is walked in place and then carried onto its own position -- backwards through
 * the modules before the owner, shifted, forward through the rest -- and everything else, which
 * takes the one direction it was asked for, border included. Returns FALSE when a transform
 * failed; the caller owns the buffers either way. */
static gboolean _brush_outline_transform(dt_develop_t *develop, const dt_masks_form_t *const mask_form,
                                         const double iop_order, const int transform_direction,
                                         const dt_masks_distort_t *const dist, const int use_source,
                                         const _brush_outline_t *const o)
{
  if(use_source && transform_direction == DT_DEV_TRANSFORM_DIR_ALL)
  {
    // we transform with all distortion that happen *before* the module
    // so we have now the TARGET points in module input reference
    if(!dt_masks_distort_transform(dist, iop_order, DT_DEV_TRANSFORM_DIR_BACK_EXCL, o->points, o->point_count))
      return TRUE;
 
    // now we move all the points by the shift
    // so we have now the SOURCE points in module input reference
    float pts[2] = { mask_form->source[0], mask_form->source[1] };
    dt_dev_coordinates_raw_norm_to_raw_abs(develop, pts, 1);
    if(!dt_masks_distort_transform(dist, iop_order, DT_DEV_TRANSFORM_DIR_BACK_EXCL, pts, 1)) return FALSE;
 
    const float dx = pts[0] - o->points[2];
    const float dy = pts[1] - o->points[3];
    float *const points = o->points;
    const int count = o->point_count;
    __OMP_PARALLEL_FOR_SIMD__(if(count > 100) aligned(points:64))
    for(int i = 0; i < count; i++)
    {
      points[i * 2] += dx;
      points[i * 2 + 1] += dy;
    }
 
    // we apply the rest of the distortions (those after the module)
    // so we have now the SOURCE points in final image reference
    return dt_masks_distort_transform(dist, iop_order, DT_DEV_TRANSFORM_DIR_FORW_INCL, o->points, o->point_count);
  }
 
  if(!dt_masks_distort_transform(dist, iop_order, transform_direction, o->points, o->point_count)) return FALSE;
  if(IS_NULL_PTR(o->border)) return TRUE;
  return dt_masks_distort_transform(dist, iop_order, transform_direction, o->border, o->border_count);
}
 
// Brush points are stored in a cyclic way because the border goes around the main line.
// This means that it record the main line twice (up and down) while the border only once (around).
static int _brush_get_pts_border(dt_develop_t *develop, dt_masks_form_t *mask_form,
                                 const double iop_order, const int transform_direction,
                                 const dt_masks_distort_t *const dist, float **point_buffer, int *point_count,
                                 float **border_buffer, int *border_count, float **payload_buffer,
                                 int *payload_count, dt_masks_skip_range_t **border_skips,
                                 int *border_skip_count, int use_source)
{
  *point_buffer = NULL;
  *point_count = 0;
  if(border_buffer) *border_buffer = NULL;
  if(!IS_NULL_PTR(border_buffer)) *border_count = 0;
  if(payload_buffer) *payload_buffer = NULL;
  if(!IS_NULL_PTR(payload_buffer)) *payload_count = 0;
  if(!IS_NULL_PTR(border_skips)) *border_skips = NULL;
  if(!IS_NULL_PTR(border_skip_count)) *border_skip_count = 0;
 
  if(IS_NULL_PTR(mask_form) || IS_NULL_PTR(mask_form->points)) return 0;
  double start2 = 0.0;
  if(dt_get_debug_flags() & DT_DEBUG_PERF) start2 = dt_get_wtime();
 
  const float iwd = dist->iwidth;
  const float iht = dist->iheight;
  // How far apart consecutive samples of the outline may land, in image pixels. Decided by the
  // pipe, never here; see dt_dev_pixelpipe_t::mask_rasterization_step. Above 1 the samples
  // spread out and the radial spokes stamped from them leave gaps between each pair (#1116).
  const int pixel_threshold = dist->rasterization_step;
 
  dt_masks_dynbuf_t *dpoints = NULL;
  dt_masks_dynbuf_t *dborder = NULL;
  dt_masks_dynbuf_t *dpayload = NULL;
  if(!_brush_bufs_alloc(!IS_NULL_PTR(border_buffer), !IS_NULL_PTR(payload_buffer), &dpoints, &dborder, &dpayload))
    return 1;
 
  // we store all points
  float dx = 0.0f;
  float dy = 0.0f;
 
  if(use_source && mask_form->points && transform_direction != DT_DEV_TRANSFORM_DIR_ALL)
  {
    dt_masks_node_brush_t *pt = (dt_masks_node_brush_t *)mask_form->points->data;
    dx = (pt->node[0] - mask_form->source[0]) * iwd;
    dy = (pt->node[1] - mask_form->source[1]) * iht;
  }
 
  const guint node_count = g_list_length(mask_form->points);
 
  dt_masks_node_brush_t **nodes = dt_alloc_align((size_t)node_count * sizeof(*nodes));
  if(!nodes)
  {
    dt_masks_dynbuf_free(dpoints);
    dt_masks_dynbuf_free(dborder);
    dt_masks_dynbuf_free(dpayload);
    return 1;
  }
 
  guint node_index = 0;
  for(GList *form_points = mask_form->points; form_points; form_points = g_list_next(form_points))
  {
    const dt_masks_node_brush_t *const pt = (dt_masks_node_brush_t *)form_points->data;
    nodes[node_index++] = (dt_masks_node_brush_t *)form_points->data;
    float *const buf = dt_masks_dynbuf_reserve_n(dpoints, 6);
    if (buf)
    {
      buf[0] = pt->ctrl1[0] * iwd - dx;
      buf[1] = pt->ctrl1[1] * iht - dy;
      buf[2] = pt->node[0] * iwd - dx;
      buf[3] = pt->node[1] * iht - dy;
      buf[4] = pt->ctrl2[0] * iwd - dx;
      buf[5] = pt->ctrl2[1] * iht - dy;
    }
  }
 
  // for the border, we store value too
  if(!IS_NULL_PTR(dborder))
  {
    dt_masks_dynbuf_add_zeros(dborder, 6 * node_count);  // we need six zeros for each border point
  }
 
  // for the payload, we reserve an equivalent number of cells to keep it in sync
  if(!IS_NULL_PTR(dpayload))
  {
    dt_masks_dynbuf_add_zeros(dpayload, 6 * node_count); // we need six zeros for each border point
  }
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] brush_points init took %0.04f sec\n", mask_form->name,
             dt_get_wtime() - start2);
    start2 = dt_get_wtime();
  }
 
  const _brush_walk_t walk = { .nodes = nodes,
                               .node_count = (int)node_count,
                               .frame = { iwd, iht, dx, dy },
                               .pixel_threshold = pixel_threshold,
                               .arc_step = IS_NULL_PTR(dist->pipe) ? pixel_threshold : 1,
                               .dpoints = dpoints,
                               .dborder = dborder,
                               .dpayload = dpayload };
  if(_brush_walk_pass(&walk, TRUE))
    _brush_walk_pass(&walk, FALSE);
  else
    _brush_walk_single_dab(&walk);
 
  dt_free_align(nodes);
 
  *point_count = dt_masks_dynbuf_position(dpoints) / 2;
  *point_buffer = dt_masks_dynbuf_harvest(dpoints);
  dt_masks_dynbuf_free(dpoints);
 
  if(!IS_NULL_PTR(dborder))
  {
    *border_count = dt_masks_dynbuf_position(dborder) / 2;
    *border_buffer = dt_masks_dynbuf_harvest(dborder);
    dt_masks_dynbuf_free(dborder);
  }
 
  if(!IS_NULL_PTR(dpayload))
  {
    *payload_count = dt_masks_dynbuf_position(dpayload) / 2;
    *payload_buffer = dt_masks_dynbuf_harvest(dpayload);
    dt_masks_dynbuf_free(dpayload);
  }
 
  // printf("points %d, border %d, playload %d\n", *points_count, border ? *border_count : -1, payload ?
  // *payload_count : -1);
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] brush_points point recurs %0.04f sec\n", mask_form->name,
             dt_get_wtime() - start2);
    start2 = dt_get_wtime();
  }
 
  // and we transform them with all distorted modules
  const _brush_outline_t outline = { .points = *point_buffer,
                                     .point_count = *point_count,
                                     .border = IS_NULL_PTR(border_buffer) ? NULL : *border_buffer,
                                     .border_count = IS_NULL_PTR(border_buffer) ? 0 : *border_count };
  if(_brush_outline_transform(develop, mask_form, iop_order, transform_direction, dist, use_source, &outline))
  {
    if(dt_get_debug_flags() & DT_DEBUG_PERF)
      dt_print(DT_DEBUG_MASKS, "[masks %s] brush_points transform took %0.04f sec\n", mask_form->name,
               dt_get_wtime() - start2);
    return 0;
  }
 
  // if we failed, then free all and return
  dt_pixelpipe_cache_free_align(*point_buffer);
  *point_buffer = NULL;
  *point_count = 0;
  if(!IS_NULL_PTR(border_buffer))
  {
    dt_pixelpipe_cache_free_align(*border_buffer);
    *border_buffer = NULL;
    *border_count = 0;
  }
  if(!IS_NULL_PTR(payload_buffer))
  {
    dt_pixelpipe_cache_free_align(*payload_buffer);
    *payload_buffer = NULL;
    *payload_count = 0;
  }
  return 1;
}
 
static void _brush_get_distance(float point_x, float point_y, float radius,
                                dt_masks_form_gui_t *mask_gui, int form_index,
                                int corner_count, int *inside, int *inside_border,
                                int *near_handle, int *inside_source, float *distance)
{
  if(IS_NULL_PTR(mask_gui)) return;
 
  // initialise returned values
  *inside_source = 0;
  *inside = 0;
  *inside_border = 0;
  *near_handle = -1;
  *distance = FLT_MAX;
 
  dt_masks_form_gui_points_t *gui_points
      = (dt_masks_form_gui_points_t *)g_list_nth_data(mask_gui->points, form_index);
  if(IS_NULL_PTR(gui_points)) return;
  /* Nothing to walk when the cursor cannot reach a sample: the box every sample spans, grown by
   * the cursor's reach, answers for the whole shape in four comparisons, and every answer
   * initialised above is what the walk would have given -- nothing inside, nothing near. */
  if(!dt_masks_gui_points_reach(gui_points, point_x, point_y, 2.0f * radius)) return;
 
  float min_dist = FLT_MAX;
 
  const float radius2 = radius * radius;
 
  // we first check if we are inside the source form
 
  // add support for clone masks
  if(gui_points->points && gui_points->source
     && gui_points->points_count > 2 + corner_count * 3
     && gui_points->source_count > 2 + corner_count * 3)
  {
    // distance from form origin and source origin
    const float dx = -gui_points->points[2] + gui_points->source[2];
    const float dy = -gui_points->points[3] + gui_points->source[3];
 
    int current_seg = 1;
    for(int i = corner_count * 3; i < gui_points->points_count; i++)
    {
      // do we change of path segment ?
      if(gui_points->points[i * 2 + 1] == gui_points->points[current_seg * 6 + 3]
         && gui_points->points[i * 2] == gui_points->points[current_seg * 6 + 2])
      {
        current_seg = (current_seg + 1) % corner_count;
      }
      // distance from tested point to current form point
      const float yy = gui_points->points[i * 2 + 1] + dy;
      const float xx = gui_points->points[i * 2] + dx;
 
      const float sdx = point_x - xx;
      const float sdy = point_y - yy;
      const float dd = (sdx * sdx) + (sdy * sdy);
      if(dd < min_dist)
      {
        min_dist = dd;
 
        if(dd < radius2 && *inside == 0)
        {
          if(current_seg == 0)
            *inside_source = corner_count - 1;
          else
            *inside_source = current_seg - 1;
 
          if(*inside_source)
          {
            *inside = 1;
          }
        }
      }
    }
  }
 
  // we check if we are near a segment of the centerline. This runs BEFORE the outline test:
  // the outline wraps the whole stroke, so on a thin brush both are within cursor reach at
  // once, and the segment is the one carrying an action (move it, Ctrl+Click to add a node)
  // while the outline has none of its own.
  if(gui_points->points && gui_points->points_count > 2 + corner_count * 3)
  {
    // Own accumulator: the source pass above walks a different outline, and its distances
    // must not veto a segment hit on the form itself.
    float min_dist_points = FLT_MAX;
    int current_seg = 1;
    for(int i = corner_count * 3; i < gui_points->points_count; i++)
    {
      // do we change of path segment ?
      if(gui_points->points[i * 2 + 1] == gui_points->points[current_seg * 6 + 3]
         && gui_points->points[i * 2] == gui_points->points[current_seg * 6 + 2])
      {
        current_seg = (current_seg + 1) % corner_count;
      }
      //distance from tested point to current form point
      const float yy = gui_points->points[i * 2 + 1];
      const float xx = gui_points->points[i * 2];
 
      const float dx = point_x - xx;
      const float dy = point_y - yy;
      const float dd = (dx * dx) + (dy * dy);
      if(dd < min_dist_points)
      {
        min_dist_points = dd;
 
        if(current_seg > 0 && dd < radius2)
        {
          *near_handle = current_seg - 1;
        }
      }
    }
    min_dist = MIN(min_dist, min_dist_points);
  }
 
 // we check if it's inside borders
  if(gui_points->border && gui_points->border_count > 2 + corner_count * 3)
  {
    int nearest = -1;
 
    const int start = corner_count * 3;
    const float *const border = gui_points->border;
    float last_y = border[gui_points->border_count * 2 - 1];
    int crossings = 0;
 
    for(int i = start; i < gui_points->border_count; i++)
    {
      const int idx = i * 2;
      const float xx = border[idx];
      const float yy = border[idx + 1];
 
      const float dx = point_x - xx;
      const float dy = point_y - yy;
      if(dx * dx + dy * dy < radius2) nearest = idx;
 
      if(((point_y <= yy && point_y > last_y) || (point_y >= yy && point_y < last_y)) && (xx > point_x))
        crossings++;
 
      last_y = yy;
    }
 
    // Being enclosed by the outline is what makes the stroke hoverable at all, but it is not
    // a hit on the border itself: only proximity to the outline is, and only where no
    // centerline segment is closer. Reporting the whole band as border made the segment
    // unreachable, since the shared hit test answers on the border before the segment.
    *inside = (nearest != -1 || (crossings & 1));
    *inside_border = (nearest != -1) && (*near_handle < 0);
  }
 
  *distance = min_dist;
}
 
 
static dt_masks_raster_result_t _brush_get_points_border(dt_develop_t *develop, dt_masks_form_t *mask_form,
                                    float **point_buffer, int *point_count,
                                    float **border_buffer, int *border_count,
                                    dt_masks_skip_range_t **border_skips, int *border_skip_count,
                                    int use_source, const dt_iop_module_t *module)
{
  if(!IS_NULL_PTR(border_skips)) *border_skips = NULL;
  if(!IS_NULL_PTR(border_skip_count)) *border_skip_count = 0;
 
  // Asking for the source outline without a module is a programming error, not an empty shape.
  if(use_source && IS_NULL_PTR(module)) return DT_MASKS_RASTER_ERROR;
  const double ioporder = (module) ? module->iop_order : 0.0f;
  const dt_masks_distort_t gui_dist = dt_masks_distort_for_gui(develop);
  const int status
      = _brush_get_pts_border(develop, mask_form, ioporder, DT_DEV_TRANSFORM_DIR_ALL,
                              &gui_dist, point_buffer, point_count, border_buffer,
                              border_count, NULL, NULL, border_skips, border_skip_count, use_source);
 
  /* This outline feeds the GUI only -- the rasterisers build their own from the pixel path and
   * paint every spoke. What the outline shows is the BOUNDARY of what they paint, decided per
   * sample by dt_masks_outline_boundary_skips(); the excluded samples travel out-of-band as skip
   * ranges, which is what every consumer of this outline already reads. */
  if(status == 0 && !IS_NULL_PTR(border_buffer) && !IS_NULL_PTR(*border_buffer)
     && !IS_NULL_PTR(border_skips) && !IS_NULL_PTR(border_skip_count))
  {
    const int header = (int)g_list_length(mask_form->points) * 3;
    dt_pixelpipe_cache_free_align(*border_skips);
    *border_skips = NULL;
    *border_skip_count = dt_masks_outline_boundary_skips(*point_buffer, *border_buffer, *border_count, header,
                                                         border_skips);
  }
 
  return dt_masks_raster_from_status(status);
}
 
static float _brush_get_position_in_segment(float point_x, float point_y,
                                            dt_masks_form_t *mask_form, int segment_index)
{
  if(IS_NULL_PTR(mask_form) || IS_NULL_PTR(mask_form->points)) return 0;
  GList *first_node_entry = g_list_nth(mask_form->points, segment_index);
  dt_masks_node_brush_t *point0 = (dt_masks_node_brush_t *)first_node_entry->data;
  // advance to next node in list, if not already on the last
  GList *next_node_entry = g_list_next_bounded(first_node_entry);
  dt_masks_node_brush_t *point1 = (dt_masks_node_brush_t *)next_node_entry->data;
  next_node_entry = g_list_next_bounded(next_node_entry);
  dt_masks_node_brush_t *point2 = (dt_masks_node_brush_t *)next_node_entry->data;
  next_node_entry = g_list_next_bounded(next_node_entry);
  dt_masks_node_brush_t *point3 = (dt_masks_node_brush_t *)next_node_entry->data;
 
  float best_t = 0.0f;
  float best_dist2 = FLT_MAX;
 
  for(int sample_index = 0; sample_index <= 100; sample_index++)
  {
    const float t = sample_index / 100.0f;
    float sample_x = 0.0f;
    float sample_y = 0.0f;
    _brush_get_XY(point0->node[0], point0->node[1], point1->node[0], point1->node[1],
                  point2->node[0], point2->node[1], point3->node[0], point3->node[1], t, &sample_x, &sample_y);
 
    const float dist2 = (point_x - sample_x) * (point_x - sample_x)
                        + (point_y - sample_y) * (point_y - sample_y);
    if(dist2 < best_dist2)
    {
      best_dist2 = dist2;
      best_t = t;
    }
  }
 
  return best_t;
}
 
static gboolean _brush_border_handle_cb(const dt_masks_form_gui_points_t *gui_points, int node_count, int node_index,
                                        float *handle_x, float *handle_y, void *user_data)
{
  return _brush_get_border_handle_mirrored(gui_points, node_count, node_index, handle_x, handle_y);
}
 
static void _brush_curve_handle_cb(const dt_masks_form_gui_points_t *gui_points, int node_index,
                                   float *handle_x, float *handle_y, void *user_data)
{
  _brush_ctrl2_to_handle(gui_points->points[node_index * 6 + 2], gui_points->points[node_index * 6 + 3],
                         gui_points->points[node_index * 6 + 4], gui_points->points[node_index * 6 + 5],
                         handle_x, handle_y, TRUE);
}
 
static void _brush_distance_cb(float pointer_x, float pointer_y, float cursor_radius,
                               dt_masks_form_gui_t *mask_gui, int form_index, int node_count, int *inside,
                               int *inside_border, int *near_handle, int *inside_source, float *dist, void *user_data)
{
  _brush_get_distance(pointer_x, pointer_y, cursor_radius, mask_gui, form_index, node_count,
                      inside, inside_border, near_handle, inside_source, dist);
}
 
static int _find_closest_handle(dt_masks_form_t *mask_form, dt_masks_form_gui_t *mask_gui, int form_index)
{
  return dt_masks_find_closest_handle_common(mask_form, mask_gui, form_index, -1,
                                             _brush_border_handle_cb, _brush_curve_handle_cb, NULL,
                                             _brush_distance_cb, NULL, NULL);
}
 
 
static int _init_fading(dt_masks_form_t *mask_form, int parentid, dt_masks_form_gui_t *mask_gui,
                        const float amount, const dt_masks_increment_t increment, const int flow)
{
  const float masks_fading = dt_masks_get_set_conf_value_with_toast(mask_form, "fading", amount,
                                                                    FADING_MIN, FADING_MAX, increment, flow,
                                                                    _("fading: %3.2f%%"), 100.0f);
  if(mask_gui->guipoints_count > 0)
    dt_masks_dynbuf_set(mask_gui->guipoints_payload, -3, masks_fading);
  return 1;
}
 
static int _init_size(dt_masks_form_t *mask_form, int parentid, dt_masks_form_gui_t *mask_gui,
                      const float amount, const dt_masks_increment_t increment, const int flow)
{
  const float masks_border = dt_masks_get_set_conf_value_with_toast(mask_form, "border", amount,
                                                                    FADING_MIN, FADING_MAX, increment, flow,
                                                                    _("size: %3.2f%%"), 2.f * 100.f);
  if(mask_gui->guipoints_count > 0)
    dt_masks_dynbuf_set(mask_gui->guipoints_payload, -4, masks_border);
  return 1;
}
 
static int _init_opacity(dt_masks_form_t *mask_form, int parentid, dt_masks_form_gui_t *mask_gui,
                         const float amount, const dt_masks_increment_t increment, const int flow)
{
  dt_masks_get_set_conf_value_with_toast(mask_form, "opacity", amount, 0.f, 1.f,
                                         increment, flow, _("opacity: %3.2f%%"), 100.f);
  return 1;
}
 
static float _brush_get_interaction_value(const dt_masks_form_t *mask_form, dt_masks_interaction_t interaction)
{
  if(IS_NULL_PTR(mask_form) || IS_NULL_PTR(mask_form->points)) return NAN;
 
  switch(interaction)
  {
    case DT_MASKS_INTERACTION_SIZE:
    {
      const float size = dt_masks_get_form_size_from_nodes(mask_form->points);
      if(size <= 0.0f) return NAN;
      return size;
    }
    case DT_MASKS_INTERACTION_FADING:
    {
      float fading_sum = 0.0f;
      int fading_count = 0;
 
      for(const GList *point_node = mask_form->points; point_node; point_node = g_list_next(point_node))
      {
        const dt_masks_node_brush_t *node = (const dt_masks_node_brush_t *)point_node->data;
        if(IS_NULL_PTR(node)) continue;
        fading_sum += node->fading;
        fading_count++;
      }
 
      return fading_count > 0 ? fading_sum / (float)fading_count : NAN;
    }
    default:
      return NAN;
  }
}
 
static gboolean _brush_get_gravity_center(dt_develop_t *dev, const dt_masks_form_t *mask_form, float center[2], float *area)
{
  if(IS_NULL_PTR(mask_form) || IS_NULL_PTR(mask_form->points)) return FALSE;
 
  const int points_count = g_list_length(mask_form->points);
  if(points_count <= 0) return FALSE;
 
  float *point_buffer = dt_alloc_align_float((size_t)points_count * 2);
  if(IS_NULL_PTR(point_buffer)) return FALSE;
 
  int i = 0;
  for(const GList *l = mask_form->points; l; l = g_list_next(l))
  {
    const dt_masks_node_brush_t *point = (const dt_masks_node_brush_t *)l->data;
    if(IS_NULL_PTR(point)) continue;
    point_buffer[2 * i] = point->node[0];
    point_buffer[2 * i + 1] = point->node[1];
    i++;
  }
 
  const gboolean ok = dt_masks_center_of_gravity_from_points(point_buffer, i, center, area);
  dt_free_align(point_buffer);
  return ok;
}
 
static int _change_fading(dt_masks_form_t *mask_form, int parentid, dt_masks_form_gui_t *mask_gui,
                          struct dt_iop_module_t *module, int index, const float amount,
                          const dt_masks_increment_t increment, const int flow);
static int _change_size(dt_masks_form_t *mask_form, int parentid, dt_masks_form_gui_t *mask_gui,
                        struct dt_iop_module_t *module, int index, const float amount,
                        const dt_masks_increment_t increment, const int flow);
 
static float _brush_set_interaction_value(dt_masks_form_t *mask_form, dt_masks_interaction_t interaction, float value,
                                          dt_masks_increment_t increment, int flow,
                                          dt_masks_form_gui_t *mask_gui, struct dt_iop_module_t *module)
{
  if(IS_NULL_PTR(mask_form)) return NAN;
  // Mirrors _dt_masks_events_get_dispatch_form()'s form_index: this shape's position in the
  // currently displayed group, so dt_masks_gui_form_create() below refreshes the right
  // mask_gui->points slot instead of clobbering whatever shape sits at index 0.
  const int index = (!IS_NULL_PTR(mask_gui) && mask_gui->group_selected >= 0) ? mask_gui->group_selected : 0;
 
  switch(interaction)
  {
    case DT_MASKS_INTERACTION_SIZE:
      if(!_change_size(mask_form, 0, mask_gui, module, index, value, increment, flow)) return NAN;
      return _brush_get_interaction_value(mask_form, interaction);
    case DT_MASKS_INTERACTION_FADING:
      if(!_change_fading(mask_form, 0, mask_gui, module, index, value, increment, flow)) return NAN;
      return _brush_get_interaction_value(mask_form, interaction);
    default:
      return NAN;
  }
}
 
static int _change_fading(dt_masks_form_t *mask_form, int parentid, dt_masks_form_gui_t *mask_gui,
                          struct dt_iop_module_t *module, int index, const float amount,
                          const dt_masks_increment_t increment, const int flow)
{
  if(IS_NULL_PTR(mask_form) || IS_NULL_PTR(mask_form->points)) return 0;
  int node_index = 0;
  const float scale_amount = 1.f / powf(amount, (float)flow);
  const float offset_amount = -amount * (float)flow;
  float result_amount = 0.0f;
  for(GList *node_entry = mask_form->points; node_entry; node_entry = g_list_next(node_entry), node_index++)
  {
    if(dt_masks_gui_change_affects_selected_node_or_all(mask_gui, node_index))
    {
      dt_masks_node_brush_t *node = (dt_masks_node_brush_t *)node_entry->data;
      const float current_fading = node->fading;
      result_amount = dt_masks_apply_increment_precomputed(current_fading, amount, scale_amount, offset_amount, increment);
 
      node->fading = CLAMPF(result_amount, FADING_MIN, FADING_MAX);
    }
  }
 
  dt_masks_get_set_conf_value(mask_form, "fading", result_amount, FADING_MIN, FADING_MAX, increment, flow);
 
  // we recreate the form points
  dt_masks_gui_form_create(mask_form, mask_gui, index, module);
 
  return 1;
}
 
static int _change_size(dt_masks_form_t *mask_form, int parentid, dt_masks_form_gui_t *mask_gui,
                        struct dt_iop_module_t *module, int index, const float amount,
                        const dt_masks_increment_t increment, const int flow)
{
  if(IS_NULL_PTR(mask_form) || IS_NULL_PTR(mask_form->points)) return 0;
  // Sanitize loop
  // do not exceed upper limit of 1.0 and lower limit of 0.004
  int node_index = 0;
  for(GList *node_entry = mask_form->points; node_entry; node_entry = g_list_next(node_entry), node_index++)
  {
    if(dt_masks_gui_change_affects_selected_node_or_all(mask_gui, node_index))
    {
      dt_masks_node_brush_t *node = (dt_masks_node_brush_t *)node_entry->data;
      if(!node) continue;
      if(amount > 1.0f && (node->border[0] > 1.0f || node->border[1] > 1.0f))
        return 1;
    }
  }
 
  // Growing/shrinking loop
  const float scale_amount = amount;
  const float offset_amount = amount;
  node_index = 0;
  for(GList *node_entry = mask_form->points; node_entry; node_entry = g_list_next(node_entry), node_index++)
  {
    if(dt_masks_gui_change_affects_selected_node_or_all(mask_gui, node_index))
    {
      dt_masks_node_brush_t *node = (dt_masks_node_brush_t *)node_entry->data;
      if(!node) continue;
      node->border[0] = dt_masks_apply_increment_precomputed(node->border[0], amount,
                                                              scale_amount, offset_amount, increment);
      node->border[1] = dt_masks_apply_increment_precomputed(node->border[1], amount,
                                                              scale_amount, offset_amount, increment);
    }
  }
 
  dt_masks_get_set_conf_value(mask_form, "border", amount, FADING_MIN, FADING_MAX, increment, flow);
 
  // we recreate the form points
  if(!IS_NULL_PTR(mask_gui) && !IS_NULL_PTR(module)) dt_masks_gui_form_create(mask_form, mask_gui, index, module);
 
  return 1;
}
 
/* Shape handlers receive widget-space coordinates, while normalized output-image
 * coordinates come from `mask_gui->rel_pos` and absolute output-image
 * coordinates come from `mask_gui->pos`. */
static int _brush_events_mouse_scrolled(struct dt_iop_module_t *module, double widget_x, double widget_y,
                                        int scroll_up, const int flow, uint32_t state, dt_masks_form_t *mask_form,
                                        int parentid, dt_masks_form_gui_t *mask_gui, int index,
                                        dt_masks_interaction_t interaction)
{
  
  
  
  /* `state` is the caller's raw key state, kept for the callback signature: the property to
   * act on was already resolved from it by dt_masks_scroll_get_interaction(). A brush owns no
   * rotation, so that mapping falls through and the wheel does nothing here. Size and fading
   * apply to the selected node when there is one, to every node otherwise -- that scoping is
   * the selection's business (dt_masks_gui_change_affects_selected_node_or_all), not the
   * wheel's. */
  if(mask_gui->creation)
  {
    switch(interaction)
    {
      case DT_MASKS_INTERACTION_FADING:
        return _init_fading(mask_form, parentid, mask_gui, scroll_up ? 1.02f : 0.98f,
                            DT_MASKS_INCREMENT_SCALE, flow);
      case DT_MASKS_INTERACTION_OPACITY:
        return _init_opacity(mask_form, parentid, mask_gui, scroll_up ? +0.02f : -0.02f,
                             DT_MASKS_INCREMENT_OFFSET, flow);
      case DT_MASKS_INTERACTION_SIZE:
        return _init_size(mask_form, parentid, mask_gui, scroll_up ? 1.02f : 0.98f,
                          DT_MASKS_INCREMENT_SCALE, flow);
      default:
        return 0;
    }
  }
  else if(dt_masks_is_anything_selected(mask_gui) || mask_gui->node_hovered >= 0)
  {
    // we register the current position
    if(mask_gui->scrollx == 0.0f && mask_gui->scrolly == 0.0f)
    {
      mask_gui->scrollx = mask_gui->pos[0];
      mask_gui->scrolly = mask_gui->pos[1];
    }
 
    switch(interaction)
    {
      case DT_MASKS_INTERACTION_OPACITY:
        return dt_masks_form_change_opacity(mask_gui->dev, mask_form, parentid, scroll_up, flow);
      case DT_MASKS_INTERACTION_FADING:
        return _change_fading(mask_form, parentid, mask_gui, module, index, scroll_up ? -0.01f : 0.01f,
                              DT_MASKS_INCREMENT_OFFSET, flow);
      case DT_MASKS_INTERACTION_SIZE:
        return _change_size(mask_form, parentid, mask_gui, module, index, scroll_up ? 1.02f : 0.98f,
                            DT_MASKS_INCREMENT_SCALE, flow);
      default:
        return 0;
    }
  }
  return 0;
}
 
 
static void _get_pressure_sensitivity(dt_masks_form_gui_t *mask_gui)
{
  mask_gui->pressure_sensitivity = DT_MASKS_PRESSURE_OFF;
  const char *psens = dt_conf_get_string_const("pressure_sensitivity");
  if(!IS_NULL_PTR(psens))
  {
    if(!strcmp(psens, "fading (absolute)"))
      mask_gui->pressure_sensitivity = DT_MASKS_PRESSURE_FADING_ABS;
    else if(!strcmp(psens, "fading (relative)"))
      mask_gui->pressure_sensitivity = DT_MASKS_PRESSURE_FADING_REL;
    else if(!strcmp(psens, "opacity (absolute)"))
      mask_gui->pressure_sensitivity = DT_MASKS_PRESSURE_OPACITY_ABS;
    else if(!strcmp(psens, "opacity (relative)"))
      mask_gui->pressure_sensitivity = DT_MASKS_PRESSURE_OPACITY_REL;
    else if(!strcmp(psens, "brush size (relative)"))
      mask_gui->pressure_sensitivity = DT_MASKS_PRESSURE_BRUSHSIZE_REL;
  }
}
 
static void _add_node_to_segment(struct dt_iop_module_t *module, dt_masks_form_t *mask_form, int parentid,
                                 dt_masks_form_gui_t *mask_gui, int index)
{
  if(IS_NULL_PTR(mask_form) || IS_NULL_PTR(mask_form->points) || IS_NULL_PTR(mask_gui)) return;
  const guint node_count = g_list_length(mask_form->points);
  const int selected_segment = dt_masks_gui_selected_segment_index(mask_gui);
  if(selected_segment < 0 || selected_segment >= (int)node_count) return;
 
  // we add a new node to the brush
  dt_masks_node_brush_t *new_node = (dt_masks_node_brush_t *)(malloc(sizeof(dt_masks_node_brush_t)));
  if(IS_NULL_PTR(new_node)) return;
 
  // set coordinates
  dt_masks_gui_cursor_to_raw_norm(mask_gui->dev, mask_gui, new_node->node);
  new_node->ctrl1[0] = new_node->ctrl1[1] = new_node->ctrl2[0] = new_node->ctrl2[1] = -1.0;
  new_node->state = DT_MASKS_POINT_STATE_NORMAL;
 
  // set other attributes of the new node. we interpolate the starting and the end node of that
  // segment
  const float t = _brush_get_position_in_segment(new_node->node[0], new_node->node[1],
                                                 mask_form, selected_segment);
  // start and end node of the segment
  GList *pt = g_list_nth(mask_form->points, selected_segment);
  if(IS_NULL_PTR(pt) || IS_NULL_PTR(pt->data))
  {
    dt_free(new_node);
    return;
  }
  dt_masks_node_brush_t *point0 = (dt_masks_node_brush_t *)pt->data;
  const GList *const next_pt = g_list_next_wraparound(pt, mask_form->points);
  if(IS_NULL_PTR(next_pt) || IS_NULL_PTR(next_pt->data))
  {
    dt_free(new_node);
    return;
  }
  dt_masks_node_brush_t *point1 = (dt_masks_node_brush_t *)next_pt->data;
  new_node->border[0] = point0->border[0] * (1.0f - t) + point1->border[0] * t;
  new_node->border[1] = point0->border[1] * (1.0f - t) + point1->border[1] * t;
  new_node->fading = point0->fading * (1.0f - t) + point1->fading * t;
  new_node->density = point0->density * (1.0f - t) + point1->density * t;
 
  mask_form->points = g_list_insert(mask_form->points, new_node, selected_segment + 1);
  _brush_init_ctrl_points(mask_form);
  
  dt_masks_gui_form_create(mask_form, mask_gui, index, module);
 
  mask_gui->node_hovered = selected_segment + 1;
  mask_gui->node_selected = TRUE;
  mask_gui->node_selected_idx = selected_segment + 1;
  mask_gui->seg_hovered = -1;
  mask_gui->seg_selected = FALSE;
}
 
static inline void _brush_translate_node(dt_masks_node_brush_t *node, const float delta_x, const float delta_y)
{
  dt_masks_translate_ctrl_node(node->node, node->ctrl1, node->ctrl2, delta_x, delta_y);
}
 
static void _brush_translate_all_nodes(dt_masks_form_t *mask_form, const float delta_x, const float delta_y)
{
  for(GList *node_entry = mask_form->points; node_entry; node_entry = g_list_next(node_entry))
    _brush_translate_node((dt_masks_node_brush_t *)node_entry->data, delta_x, delta_y);
}
 
static int _brush_events_button_pressed(struct dt_iop_module_t *module, double widget_x, double widget_y,
                                        double pressure, int which, int type, uint32_t state,
                                        dt_masks_form_t *mask_form, int parentid,
                                        dt_masks_form_gui_t *mask_gui, int index)
{
  // double click or triple click: ignore here
  if(type == GDK_2BUTTON_PRESS || type == GDK_3BUTTON_PRESS) return 1;
 
  // always start with a mask density of 100%, it will be adjusted with pen pressure if used.
  const float masks_density = 1.0f;
 
  if(mask_gui->creation)
  {
    if(which == 1)
    {
      // The trick is to use the incremental setting, set to 1.0 to re-use the generic getter/setter without changing value
      float masks_border = dt_masks_get_set_conf_value(mask_form, "border", 1.0f,
                                                       FADING_MIN, FADING_MAX, TRUE, 1);
      float masks_fading = dt_masks_get_set_conf_value(mask_form, "fading", 1.0f,
                                                       FADING_MIN, FADING_MAX, TRUE, 1);
    
      if(dt_modifier_is(state, DT_PRIMARY_MASK | GDK_SHIFT_MASK) || dt_modifier_is(state, GDK_SHIFT_MASK))
      {
        // set some absolute or relative position for the source of the clone mask
        if(mask_form->type & DT_MASKS_CLONE)
          dt_masks_set_source_pos_initial_state(mask_gui, state);
 
        return 1;
      }
 
      if(IS_NULL_PTR(mask_gui->guipoints)) mask_gui->guipoints = dt_masks_dynbuf_init(200000, "brush guipoints");
      if(IS_NULL_PTR(mask_gui->guipoints)) return 1;
      if(IS_NULL_PTR(mask_gui->guipoints_payload))
        mask_gui->guipoints_payload = dt_masks_dynbuf_init(400000, "brush guipoints_payload");
      if(IS_NULL_PTR(mask_gui->guipoints_payload)) return 1;
      dt_masks_dynbuf_add_2(mask_gui->guipoints, mask_gui->pos[0], mask_gui->pos[1]);
      dt_masks_dynbuf_add_2(mask_gui->guipoints_payload, masks_border, masks_fading);
      dt_masks_dynbuf_add_2(mask_gui->guipoints_payload, masks_density, pressure);
      dt_control_mouse_is_painting(TRUE);
      mask_gui->guipoints_count = 1;
 
      // add support for clone masks
      if(mask_form->type & DT_MASKS_CLONE)
        dt_masks_set_source_pos_initial_value(mask_gui, mask_form);
      // not used by regular masks
      else
        mask_form->source[0] = mask_form->source[1] = 0.0f;
 
      _get_pressure_sensitivity(mask_gui);
 
      return 1;
    }
  }
 
  dt_masks_form_gui_points_t *gui_points
      = (dt_masks_form_gui_points_t *)g_list_nth_data(mask_gui->points, index);
  if(IS_NULL_PTR(gui_points)) return 0;
  const guint node_count = g_list_length(mask_form->points);
 
  if(which == 1)
  {
    // The shape handler runs before the shared press-state selection update,
    // so concrete hovered targets must win over stale form/source selection.
    if(mask_gui->node_hovered >= 0)
    {
      // if ctrl is pressed, we change the type of point
      if(mask_gui->node_selected && dt_modifier_is(state, DT_PRIMARY_MASK))
      {
        dt_masks_node_brush_t *node
            = (dt_masks_node_brush_t *)g_list_nth_data(mask_form->points, mask_gui->node_hovered);
        if(IS_NULL_PTR(node)) return 0;
        dt_masks_toggle_bezier_node_type(module, mask_form, mask_gui, index, gui_points,
                                         mask_gui->node_hovered, node->node, node->ctrl1, node->ctrl2,
                                         &node->state);
        return 1;
      }
      /*// we register the current position to avoid accidental move
      if(mask_gui->node_edited < 0 && mask_gui->scrollx == 0.0f && mask_gui->scrolly == 0.0f)
      {
        mask_gui->scrollx = pointer_x;
        mask_gui->scrolly = pointer_y;
      }*/
      mask_gui->delta[0] = gui_points->points[mask_gui->node_hovered * 6 + 2] - mask_gui->pos[0];
      mask_gui->delta[1] = gui_points->points[mask_gui->node_hovered * 6 + 3] - mask_gui->pos[1];
 
      return 1;
    }
    else if(mask_gui->handle_hovered >= 0)
    {
      if(!dt_masks_node_is_cusp(gui_points, mask_gui->handle_hovered))
      {
        // we need to find the handle position
        float handle_x, handle_y;
        const int k = mask_gui->handle_hovered;
        _brush_ctrl2_to_handle(gui_points->points[k * 6 + 2], gui_points->points[k * 6 + 3],
                               gui_points->points[k * 6 + 4], gui_points->points[k * 6 + 5],
                               &handle_x, &handle_y, TRUE);
        // compute offsets
        mask_gui->delta[0] = handle_x - mask_gui->pos[0];
        mask_gui->delta[1] = handle_y - mask_gui->pos[1];
 
        return 1;
      }
    }
    else if(mask_gui->handle_border_hovered >= 0)
    {
      float handle_x = 0.0f, handle_y = 0.0f;
      if(_brush_get_border_handle_mirrored(gui_points, node_count, mask_gui->handle_border_hovered,
                                           &handle_x, &handle_y))
      {
        mask_gui->delta[0] = handle_x - mask_gui->pos[0];
        mask_gui->delta[1] = handle_y - mask_gui->pos[1];
      }
 
      return 1;
    }
    else if(mask_gui->seg_hovered >= 0)
    {
      mask_gui->node_hovered = -1;
 
      if(dt_modifier_is(state, DT_PRIMARY_MASK))
      {
        _add_node_to_segment(module, mask_form, parentid, mask_gui, index);
      }
      else
      {
        // we move the entire segment
        mask_gui->delta[0] = gui_points->points[mask_gui->seg_hovered * 6 + 2] - mask_gui->pos[0];
        mask_gui->delta[1] = gui_points->points[mask_gui->seg_hovered * 6 + 3] - mask_gui->pos[1];
      }
      return 1;
    }
    else if(mask_gui->source_selected && mask_gui->edit_mode == DT_MASKS_EDIT_FULL)
    {
      // we start the source dragging
      mask_gui->delta[0] = gui_points->source[2] - mask_gui->pos[0];
      mask_gui->delta[1] = gui_points->source[3] - mask_gui->pos[1];
      return 1;
    }
    else if(mask_gui->form_selected && mask_gui->edit_mode == DT_MASKS_EDIT_FULL)
    {
      // we start the form dragging
      mask_gui->delta[0] = gui_points->points[2] - mask_gui->pos[0];
      mask_gui->delta[1] = gui_points->points[3] - mask_gui->pos[1];
      return 1;
    }
  }
 
  return 0;
}
 
static float _get_brush_smoothing()
{
  float factor = 0.01f;
  const char *smoothing = dt_conf_get_string_const("brush_smoothing");
  if(!strcmp(smoothing, "low"))
    factor = 0.0025f;
  else if(!strcmp(smoothing, "medium"))
    factor = 0.01f;
  else if(!strcmp(smoothing, "high"))
    factor = 0.04f;
  return factor;
}
 
static void _apply_pen_pressure(dt_masks_form_gui_t *mask_gui, float *payload_buffer)
{
  for(int i = 0; i < mask_gui->guipoints_count; i++)
  {
    float *payload = payload_buffer + 4 * i;
    float pressure = payload[3];
    payload[3] = 1.0f;
 
    switch(mask_gui->pressure_sensitivity)
    {
      case DT_MASKS_PRESSURE_BRUSHSIZE_REL:
        payload[0] = MAX(FADING_MIN, payload[0] * pressure);
        break;
      case DT_MASKS_PRESSURE_FADING_ABS:
        payload[1] = MAX(FADING_MIN, pressure);
        break;
      case DT_MASKS_PRESSURE_FADING_REL:
        payload[1] = MAX(FADING_MIN, payload[1] * pressure);
        break;
      case DT_MASKS_PRESSURE_OPACITY_ABS:
        payload[2] = MAX(0.05f, pressure);
        break;
      case DT_MASKS_PRESSURE_OPACITY_REL:
        payload[2] = MAX(0.05f, payload[2] * pressure);
        break;
      default:
      case DT_MASKS_PRESSURE_OFF:
        // ignore pressure value
        break;
    }
  }
}
 
 
static int _brush_events_button_released(struct dt_iop_module_t *module, double widget_x, double widget_y,
                                         int which, uint32_t state, dt_masks_form_t *mask_form, int parentid,
                                         dt_masks_form_gui_t *mask_gui, int index)
{
  
  
  if(IS_NULL_PTR(mask_gui)) return 0;
  dt_masks_form_gui_points_t *gui_points
      = (dt_masks_form_gui_points_t *)g_list_nth_data(mask_gui->points, index);
  if(IS_NULL_PTR(gui_points)) return 0;
 
  // The trick is to use the incremental setting, set to 1.0 to re-use the generic getter/setter without changing value
  float masks_border = dt_masks_get_set_conf_value(mask_form, "border", 1.0f,
                                                   FADING_MIN, FADING_MAX, TRUE, 1);
 
  if(mask_gui->creation && which == 1)
  {
    if(dt_modifier_is(state, GDK_SHIFT_MASK) || dt_modifier_is(state, DT_PRIMARY_MASK | GDK_SHIFT_MASK))
    {
      // user just set the source position, so just return
      return 1;
    }
 
    dt_iop_module_t *creation_module = mask_gui->creation_module;
 
    if(mask_gui->guipoints && mask_gui->guipoints_count > 0)
    {
      // if the path consists only of one x/y pair we add a second one close so we don't need to deal with
      // this special case later
      if(mask_gui->guipoints_count == 1)
      {
        // add a helper node very close to the single spot
        const float x = dt_masks_dynbuf_get(mask_gui->guipoints, -2) + 0.01f;
        const float y = dt_masks_dynbuf_get(mask_gui->guipoints, -1) - 0.01f;
        dt_masks_dynbuf_add_2(mask_gui->guipoints, x, y);
        const float border = dt_masks_dynbuf_get(mask_gui->guipoints_payload, -4);
        const float fading = dt_masks_dynbuf_get(mask_gui->guipoints_payload, -3);
        const float density = dt_masks_dynbuf_get(mask_gui->guipoints_payload, -2);
        const float pressure = dt_masks_dynbuf_get(mask_gui->guipoints_payload, -1);
        dt_masks_dynbuf_add_2(mask_gui->guipoints_payload, border, fading);
        dt_masks_dynbuf_add_2(mask_gui->guipoints_payload, density, pressure);
        mask_gui->guipoints_count++;
      }
 
      float *guipoints = dt_masks_dynbuf_buffer(mask_gui->guipoints);
      float *guipoints_payload = dt_masks_dynbuf_buffer(mask_gui->guipoints_payload);
 
      // we transform the points
      dt_dev_coordinates_image_abs_to_raw_norm(mask_gui->dev, guipoints, mask_gui->guipoints_count);
 
      // we consolidate pen pressure readings into payload
      _apply_pen_pressure(mask_gui, guipoints_payload);
 
      // accuracy level for node elimination, dependent on brush size
      const float epsilon2 = _get_brush_smoothing() * sqf(MAX(FADING_MIN, masks_border));
 
      // we simplify the path and generate the nodes
      mask_form->points = _brush_ramer_douglas_peucker(guipoints, mask_gui->guipoints_count,
                                                       guipoints_payload, epsilon2);
 
      // printf("guipoints_count %d, points %d\n", mask_gui->guipoints_count, g_list_length(mask_form->points));
 
      _brush_init_ctrl_points(mask_form);
 
      dt_masks_dynbuf_free(mask_gui->guipoints);
      dt_masks_dynbuf_free(mask_gui->guipoints_payload);
      mask_gui->guipoints = NULL;
      mask_gui->guipoints_payload = NULL;
      mask_gui->guipoints_count = 0;
 
      dt_masks_gui_form_save_creation(mask_gui->dev, creation_module, mask_form, mask_gui);
 
      if(mask_form->type & (DT_MASKS_CLONE | DT_MASKS_NON_CLONE))
      {
        dt_masks_form_t *grp = dt_masks_get_visible_form(mask_gui->dev);
        if(IS_NULL_PTR(grp) || !(grp->type & DT_MASKS_GROUP)) return 1;
        int group_index = 0;
        int selected_index = -1;
        for(GList *group_entry = grp->points; group_entry; group_entry = g_list_next(group_entry))
        {
          dt_masks_form_group_t *group_form = (dt_masks_form_group_t *)group_entry->data;
          if(group_form->formid == mask_form->formid)
          {
            selected_index = group_index;
            break;
          }
          group_index++;
        }
        if(selected_index < 0) return 1;
        dt_masks_form_gui_t *visible_gui = mask_gui->dev->form_gui;
        if(IS_NULL_PTR(visible_gui)) return 1;
        visible_gui->group_selected = selected_index;
 
        dt_masks_select_form(mask_gui->dev, creation_module, dt_masks_get_from_id(mask_gui->dev, mask_form->formid));
      }
    }
    else
    {
      // unlikely case of button released but no points gathered -> no form
      dt_masks_dynbuf_free(mask_gui->guipoints);
      dt_masks_dynbuf_free(mask_gui->guipoints_payload);
      mask_gui->guipoints = NULL;
      mask_gui->guipoints_payload = NULL;
      mask_gui->guipoints_count = 0;
 
      dt_masks_set_edit_mode(module, DT_MASKS_EDIT_FULL);
      dt_iop_gui_blend_masks_update(module);
 
      dt_masks_change_form_gui(mask_gui->dev, NULL);
    }
    return 1;
  }
 
  else if(which == 1)
  {
    if(dt_masks_gui_is_dragging(mask_gui))
      return 1;
  }
  return 0;
}
 
static int _brush_events_key_pressed(struct dt_iop_module_t *module, GdkEventKey *event,
                                     dt_masks_form_t *mask_form, int parentid,
                                     dt_masks_form_gui_t *mask_gui, int index)
{
  return 0;
}
 
static int _brush_events_mouse_moved(struct dt_iop_module_t *module, double widget_x, double widget_y,
                                     double pressure, int which, dt_masks_form_t *mask_form, int parentid,
                                     dt_masks_form_gui_t *mask_gui, int index)
{
  dt_develop_t *dev = mask_gui->dev;
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  const int iwidth = geometry.raw_width;
  const int iheight = geometry.raw_height;
 
  if(mask_gui->creation)
  {
    if(mask_gui->guipoints)
    {
      dt_masks_dynbuf_add_2(mask_gui->guipoints, mask_gui->pos[0], mask_gui->pos[1]);
      const float border = dt_masks_dynbuf_get(mask_gui->guipoints_payload, -4);
      const float fading = dt_masks_dynbuf_get(mask_gui->guipoints_payload, -3);
      const float density = dt_masks_dynbuf_get(mask_gui->guipoints_payload, -2);
      dt_masks_dynbuf_add_2(mask_gui->guipoints_payload, border, fading);
      dt_masks_dynbuf_add_2(mask_gui->guipoints_payload, density, pressure);
      mask_gui->guipoints_count++;
      return 1;
    }
 
    // Let the cursor motion be redrawn as it moves in GUI
    return 1;
  }
 
  if(IS_NULL_PTR(mask_form->points)) return 0;
  dt_masks_form_gui_points_t *gui_points
      = (dt_masks_form_gui_points_t *)g_list_nth_data(mask_gui->points, index);
  if(IS_NULL_PTR(gui_points)) return 0;
  const guint node_count = g_list_length(mask_form->points);
 
  if(mask_gui->node_dragging >= 0)
  {
    dt_masks_node_brush_t *dragged_node
        = (dt_masks_node_brush_t *)g_list_nth_data(mask_form->points, mask_gui->node_dragging);
    if(IS_NULL_PTR(dragged_node)) return 0;
 
    float delta_x = 0.0f;
    float delta_y = 0.0f;
    dt_masks_gui_delta_from_raw_anchor(dev, mask_gui, dragged_node->node, &delta_x, &delta_y);
    _brush_translate_node(dragged_node, delta_x, delta_y);
 
    // if first point, adjust the source position accordingly
    if((mask_form->type & DT_MASKS_CLONE) && mask_gui->node_dragging == 0)
      dt_masks_translate_source(mask_form, delta_x, delta_y);
 
    // we recreate the form points
    dt_masks_gui_form_create_throttled(mask_form, mask_gui, index, module, mask_gui->pos[0], mask_gui->pos[1]);
    return 1;
  }
  else if(mask_gui->seg_dragging >= 0)
  {
    const GList *segment_start = g_list_nth(mask_form->points, mask_gui->seg_dragging);
    const GList *segment_end = g_list_next_wraparound(segment_start, mask_form->points);
    dt_masks_node_brush_t *segment_node = (dt_masks_node_brush_t *)segment_start->data;
    dt_masks_node_brush_t *segment_node_next = (dt_masks_node_brush_t *)segment_end->data;
    if(!segment_node || !segment_node_next) return 0;
 
    float delta_x = 0.0f;
    float delta_y = 0.0f;
    dt_masks_gui_delta_from_raw_anchor(dev, mask_gui, segment_node->node, &delta_x, &delta_y);
    _brush_translate_node(segment_node, delta_x, delta_y);
    _brush_translate_node(segment_node_next, delta_x, delta_y);
 
    // if first point's segment, adjust the source position accordingly
    if((mask_form->type & DT_MASKS_CLONE) && mask_gui->seg_dragging == 0)
      dt_masks_translate_source(mask_form, delta_x, delta_y);
 
    // we recreate the form points
    dt_masks_gui_form_create_throttled(mask_form, mask_gui, index, module, mask_gui->pos[0], mask_gui->pos[1]);
    return 1;
  }
  else if(mask_gui->handle_dragging >= 0)
  {
    dt_masks_node_brush_t *node
        = (dt_masks_node_brush_t *)g_list_nth_data(mask_form->points, mask_gui->handle_dragging);
    if(IS_NULL_PTR(node)) return 0;
 
    float cursor_pos[2];
    dt_masks_gui_delta_to_image_abs(mask_gui, cursor_pos);
 
    // compute ctrl points directly from new handle position
    float control_points[4];
    _brush_handle_to_ctrl(gui_points->points[mask_gui->handle_dragging * 6 + 2],
                          gui_points->points[mask_gui->handle_dragging * 6 + 3], cursor_pos[0],
                          cursor_pos[1], &control_points[0], &control_points[1], &control_points[2],
                          &control_points[3], TRUE);
 
    dt_dev_coordinates_image_abs_to_raw_norm(dev, control_points, 2);
 
    // set new ctrl points
    dt_masks_set_ctrl_points(node->ctrl1, node->ctrl2, control_points);
    node->state = DT_MASKS_POINT_STATE_USER;
 
    _brush_init_ctrl_points(mask_form);
    // we recreate the form points
    dt_masks_gui_form_create_throttled(mask_form, mask_gui, index, module, mask_gui->pos[0], mask_gui->pos[1]);
    return 1;
  }
  else if(mask_gui->handle_border_dragging >= 0)
  {
    const int node_index = mask_gui->handle_border_dragging;
    dt_masks_node_brush_t *node
        = (dt_masks_node_brush_t *)g_list_nth_data(mask_form->points, node_index);
    if(IS_NULL_PTR(node)) return 0;
 
    float handle_x = 0.0f, handle_y = 0.0f;
    if(!_brush_get_border_handle_mirrored(gui_points, node_count, node_index, &handle_x, &handle_y))
      return 0;
 
    const float node_px = gui_points->points[node_index * 6 + 2];
    const float node_py = gui_points->points[node_index * 6 + 3];
 
    float pts[2];
    float cursor_pos[2];
    const float node_pos_gui[2] = { node_px, node_py };
    const float handle_pos[2] = { handle_x, handle_y };
    dt_masks_gui_delta_to_image_abs(mask_gui, cursor_pos);
    dt_masks_project_on_line(cursor_pos, node_pos_gui, handle_pos, pts);
 
    const float border = dt_masks_border_from_projected_handle(dev, node->node, pts, fminf(iwidth, iheight));
 
    node->border[0] = node->border[1] = border;
    // we recreate the form points
    dt_masks_gui_form_create_throttled(mask_form, mask_gui, index, module, mask_gui->pos[0], mask_gui->pos[1]);
    return 1;
  }
  else if(mask_gui->form_dragging || mask_gui->source_dragging)
  {
    dt_masks_node_brush_t *dragging_shape = (dt_masks_node_brush_t *)(mask_form->points)->data;
    if(IS_NULL_PTR(dragging_shape)) return 0;
 
    if(mask_gui->form_dragging)
    {
      float delta_x = 0.0f;
      float delta_y = 0.0f;
      dt_masks_gui_delta_from_raw_anchor(dev, mask_gui, dragging_shape->node, &delta_x, &delta_y);
      _brush_translate_all_nodes(mask_form, delta_x, delta_y);
    }
    else
    {
      float raw_pos[2];
      dt_masks_gui_delta_to_raw_norm(dev, mask_gui, raw_pos);
      mask_form->source[0] = raw_pos[0];
      mask_form->source[1] = raw_pos[1];
    }
 
    // we recreate the form points
    dt_masks_gui_form_create(mask_form, mask_gui, index, module);
    return 1;
  }
  return 0;
}
 
static inline int _brush_centerline_end(const int points_count, const int node_count)
{
  const int first = node_count * 3;
  if(points_count <= first) return points_count;
  return first + (points_count - first) / 2;
}
 
static void _brush_draw_shape(struct dt_develop_t *dev, cairo_t *cr, const float *points, const int points_count, const int node_nb, const gboolean border, const gboolean source,
                              const dt_masks_skip_range_t *skips, const int skip_count)
{
  /* dev and source are the shared shape_draw_function_t signature. */
  (void)dev; (void)source;
 
  /* The centreline is walked there and back (see _brush_centerline_end): stroking the whole
   * array would draw it twice. The border wraps the stroke and is walked once. */
  const int first = node_nb * 3 + border;
  const int last = border ? points_count : _brush_centerline_end(points_count, node_nb);
  dt_masks_draw_outline_runs(cr, points, first, last, skips, skip_count);
}
 
static float _brush_line_length(const float *line, const int first_pt, const int last_pt)
{
  float total_len = 0.0f;
  for(int i = first_pt; i < last_pt; i++)
  {
    const int i0 = i * 2;
    const int i1 = (i + 1) * 2;
    const float x0 = line[i0];
    const float y0 = line[i0 + 1];
    const float x1 = line[i1];
    const float y1 = line[i1 + 1];
    const float dx = x1 - x0;
    const float dy = y1 - y0;
    const float len = dx * dx + dy * dy;
    if(len > 1e-12f) total_len += sqrtf(len);
  }
  return total_len;
}
 
static gboolean _brush_line_point_at_length(const float *line, const int first_pt, const int last_pt,
                                            const float target_len, float *x, float *y)
{
  if(IS_NULL_PTR(line) || IS_NULL_PTR(x) || IS_NULL_PTR(y)) return FALSE;
  if(last_pt <= first_pt) return FALSE;
 
  float acc = 0.0f;
  gboolean has_fallback = FALSE;
  float fallback_x = 0.0f, fallback_y = 0.0f;
 
  for(int i = first_pt; i < last_pt; i++)
  {
    const int i0 = i * 2;
    const int i1 = (i + 1) * 2;
    const float x0 = line[i0];
    const float y0 = line[i0 + 1];
    const float x1 = line[i1];
    const float y1 = line[i1 + 1];
 
    const float dx = x1 - x0;
    const float dy = y1 - y0;
    const float len = dt_fast_hypotf(dx, dy);
    if(len <= 1e-6f) continue;
 
    has_fallback = TRUE;
    fallback_x = x1;
    fallback_y = y1;
 
    if(acc + len >= target_len)
    {
      const float t = (target_len - acc) / len;
      *x = x0 + t * dx;
      *y = y0 + t * dy;
      return TRUE;
    }
    acc += len;
  }
 
  if(!has_fallback) return FALSE;
  *x = fallback_x;
  *y = fallback_y;
  return TRUE;
}
 
static gboolean _brush_get_line_midpoint(const float *line, const int first_pt, const int last_pt,
                                         float *mx, float *my)
{
  if(IS_NULL_PTR(line) || IS_NULL_PTR(mx) || IS_NULL_PTR(my)) return FALSE;
  const float total_len = _brush_line_length(line, first_pt, last_pt);
  if(total_len <= 1e-6f) return FALSE;
 
  const float half_len = 0.5f * total_len;
  return _brush_line_point_at_length(line, first_pt, last_pt, half_len, mx, my);
}
 
static gboolean _brush_get_source_center(const dt_masks_form_gui_points_t *gui_points, const int node_count,
                                         dt_masks_gui_center_point_t *center_pt)
{
  if(IS_NULL_PTR(gui_points) || IS_NULL_PTR(center_pt)) return FALSE;
 
  // Work on the exact centerline span that is actually drawn (non-border path):
  // [node_count * 3, _brush_centerline_end())
  const int line_offset_pt = node_count * 3;
  const int points_line_end = _brush_centerline_end(gui_points->points_count, node_count); // exclusive
  const int source_line_end = _brush_centerline_end(gui_points->source_count, node_count); // exclusive
  const int line_end = MIN(points_line_end, source_line_end);
  const int line_count = line_end - line_offset_pt;
  if(line_count < 2) return FALSE;
 
  const float *const points_line = gui_points->points + 2 * line_offset_pt;
  const float *const source_line = gui_points->source + 2 * line_offset_pt;
  const int first_pt = 0;
  const int last_pt = line_count - 1;
 
  if(!_brush_get_line_midpoint(points_line, first_pt, last_pt,
                               &center_pt->main.x, &center_pt->main.y))
    return FALSE;
  if(!_brush_get_line_midpoint(source_line, first_pt, last_pt,
                               &center_pt->source.x, &center_pt->source.y))
    return FALSE;
  return TRUE;
}
 
static void _brush_events_post_expose(cairo_t *cr, float zoom_scale, dt_masks_form_gui_t *mask_gui, int index,
                                      int node_count)
{
  // in creation mode
  if(mask_gui->creation)
  {
    const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(mask_gui->dev);
    const float iwd = geometry.raw_width;
    const float iht = geometry.raw_height;
    const float min_iwd_iht = MIN(iwd, iht);
 
    if(mask_gui->guipoints_count == 0)
    {
      dt_masks_form_t *mask_form = dt_masks_get_visible_form(mask_gui->dev);
      if(IS_NULL_PTR(mask_form)) return;
 
      const float masks_border = dt_masks_get_set_conf_value(mask_form, "border", 1.0f, BORDER_MIN, BORDER_MAX,
                                                             DT_MASKS_INCREMENT_SCALE, 1);
      const float masks_fading = dt_masks_get_set_conf_value(mask_form, "fading", 1.0f, FADING_MIN,
                                                             FADING_MAX, DT_MASKS_INCREMENT_SCALE, 1);
      const float opacity = dt_conf_get_float("plugins/darkroom/masks/opacity");
 
      const float radius1 = masks_border * masks_fading * min_iwd_iht;
      const float radius2 = masks_border * min_iwd_iht;
 
      float xpos = mask_gui->pos[0];
      float ypos = mask_gui->pos[1];
      if((xpos == -1.0f && ypos == -1.0f))
      {
        xpos = 0.f;
        ypos = 0.f;
      }
 
      // draw brush circle at current mouse position
      cairo_save(cr);
      dt_widget_set_source_rgba(cr, DT_GUI_COLOR_BRUSH_CURSOR, opacity);
      cairo_set_line_width(cr, DT_DRAW_SIZE_LINE / zoom_scale);
      cairo_new_path(cr);
      cairo_arc(cr, xpos, ypos, radius1, 0, 2.0 * M_PI);
      cairo_fill_preserve(cr);
      cairo_set_source_rgba(cr, .8, .8, .8, .8);
      cairo_stroke(cr);
      cairo_new_path(cr);
      cairo_arc(cr, xpos, ypos, radius2, 0, 2.0 * M_PI);
      dt_draw_stroke_line(DT_MASKS_DASH_STICK, FALSE, cr, FALSE, zoom_scale, CAIRO_LINE_CAP_ROUND);
 
      if(mask_form->type & DT_MASKS_CLONE)
        dt_masks_draw_source_preview(cr, zoom_scale, mask_gui, xpos, ypos, xpos, ypos, FALSE);
 
      cairo_restore(cr);
    }
    else
    {
      float masks_border = 0.0f, masks_fading = 0.0f, masks_density = 0.0f;
      float radius = 0.0f, oldradius = 0.0f, opacity = 0.0f, oldopacity = 0.0f, pressure = 0.0f;
      int stroked = 1;
 
      const float *guipoints = dt_masks_dynbuf_buffer(mask_gui->guipoints);
      const float *guipoints_payload = dt_masks_dynbuf_buffer(mask_gui->guipoints_payload);
 
      cairo_save(cr);
      cairo_set_line_join(cr, CAIRO_LINE_JOIN_ROUND);
      cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
      masks_border = guipoints_payload[0];
      masks_fading = guipoints_payload[1];
      masks_density = guipoints_payload[2];
      pressure = guipoints_payload[3];
 
      switch(mask_gui->pressure_sensitivity)
      {
        case DT_MASKS_PRESSURE_FADING_ABS:
          masks_fading = MAX(FADING_MIN, pressure);
          break;
        case DT_MASKS_PRESSURE_FADING_REL:
          masks_fading = MAX(FADING_MIN, masks_fading * pressure);
          break;
        case DT_MASKS_PRESSURE_OPACITY_ABS:
          masks_density = MAX(0.05f, pressure);
          break;
        case DT_MASKS_PRESSURE_OPACITY_REL:
          masks_density = MAX(0.05f, masks_density * pressure);
          break;
        case DT_MASKS_PRESSURE_BRUSHSIZE_REL:
          masks_border = MAX(FADING_MIN, masks_border * pressure);
          break;
        default:
        case DT_MASKS_PRESSURE_OFF:
          // ignore pressure value
          break;
      }
 
      radius = oldradius = masks_border * masks_fading * min_iwd_iht;
      opacity = oldopacity = masks_density;
 
      cairo_set_line_width(cr,  DT_PIXEL_APPLY_DPI(2 * radius));
      dt_widget_set_source_rgba(cr, DT_GUI_COLOR_BRUSH_TRACE, opacity);
 
      cairo_move_to(cr, guipoints[0], guipoints[1]);
      for(int i = 1; i < mask_gui->guipoints_count; i++)
      {
        cairo_line_to(cr, guipoints[i * 2], guipoints[i * 2 + 1]);
        stroked = 0;
        masks_border = guipoints_payload[i * 4];
        masks_fading = guipoints_payload[i * 4 + 1];
        masks_density = guipoints_payload[i * 4 + 2];
        pressure = guipoints_payload[i * 4 + 3];
 
        switch(mask_gui->pressure_sensitivity)
        {
          case DT_MASKS_PRESSURE_FADING_ABS:
            masks_fading = MAX(FADING_MIN, pressure);
            break;
          case DT_MASKS_PRESSURE_FADING_REL:
            masks_fading = MAX(FADING_MIN, masks_fading * pressure);
            break;
          case DT_MASKS_PRESSURE_OPACITY_ABS:
            masks_density = MAX(0.05f, pressure);
            break;
          case DT_MASKS_PRESSURE_OPACITY_REL:
            masks_density = MAX(0.05f, masks_density * pressure);
            break;
          case DT_MASKS_PRESSURE_BRUSHSIZE_REL:
            masks_border = MAX(FADING_MIN, masks_border * pressure);
            break;
          default:
          case DT_MASKS_PRESSURE_OFF:
            // ignore pressure value
            break;
        }
 
        radius = masks_border * masks_fading * min_iwd_iht;
        opacity = masks_density;
 
        if(radius != oldradius || opacity != oldopacity)
        {
          cairo_stroke(cr);
          stroked = 1;
          cairo_set_line_width(cr,  DT_PIXEL_APPLY_DPI(2 * radius));
          dt_widget_set_source_rgba(cr, DT_GUI_COLOR_BRUSH_TRACE, opacity);
          oldradius = radius;
          oldopacity = opacity;
          cairo_move_to(cr, guipoints[i * 2], guipoints[i * 2 + 1]);
        }
      }
      if(!stroked) cairo_stroke(cr);
 
      cairo_set_line_width(cr, DT_DRAW_SIZE_LINE / zoom_scale);
      dt_widget_set_source_rgba(cr, DT_GUI_COLOR_BRUSH_CURSOR, opacity);
      cairo_new_path(cr);
      cairo_arc(cr, guipoints[2 * (mask_gui->guipoints_count - 1)],
                guipoints[2 * (mask_gui->guipoints_count - 1) + 1],
                radius, 0, 2.0 * M_PI);
      cairo_fill_preserve(cr);
      cairo_set_source_rgba(cr, .8, .8, .8, .8);
      cairo_stroke(cr);
      dt_draw_set_dash_style(cr, DT_MASKS_DASH_STICK, zoom_scale);
      cairo_new_path(cr);
      cairo_arc(cr, guipoints[2 * (mask_gui->guipoints_count - 1)],
                guipoints[2 * (mask_gui->guipoints_count - 1) + 1], masks_border * min_iwd_iht, 0,
                2.0 * M_PI);
      cairo_stroke(cr);
 
      dt_masks_form_t *visible_form = dt_masks_get_visible_form(mask_gui->dev);
      if(visible_form && (visible_form->type & DT_MASKS_CLONE))
      {
        const int i = mask_gui->guipoints_count - 1;
        dt_masks_draw_source_preview(cr, zoom_scale, mask_gui, guipoints[0], guipoints[1],
                                     guipoints[i * 2], guipoints[i * 2 + 1], TRUE);
      }
 
      cairo_restore(cr);
    }
    return;
  } // creation
 
  dt_masks_form_gui_points_t *gui_points
      = (dt_masks_form_gui_points_t *)g_list_nth_data(mask_gui->points, index);
  if(IS_NULL_PTR(gui_points)) return;
  if(IS_NULL_PTR(gui_points->points)) return;
 
  const int selected_node = dt_masks_gui_selected_node_index(mask_gui);
  const int selected_handle = dt_masks_gui_selected_handle_index(mask_gui);
  const int selected_handle_border = dt_masks_gui_selected_handle_border_index(mask_gui);
  const int selected_segment = dt_masks_gui_selected_segment_index(mask_gui);
 
  // minimum points
  if(gui_points->points_count <= node_count * 3 + 2) return;
 
  // draw path
  if(node_count > 0 && gui_points->points_count > node_count * 3 + 6) // there must be something to draw
  {
    // Rounded, not flat: a brush stroke is a paintbrush, not a ruled polygon edge, and a butt
    // cap on the outline shown here (the node-to-node centerline, not the painted falloff)
    // looked cut off square at its two open ends. Only the two true ends of the whole stroke,
    // not every node's own joint -- see dt_masks_draw_path_seg_by_seg().
    // The whole array, not the forward half: the walk stops itself on the last node (an open path
    // has node_count - 1 segments), and it must be able to REACH that node. Handing it a count
    // derived from the array length instead left it short of the last node on every brush, so the
    // last segment was never stroked -- it stayed a pending path in the cairo context.
    dt_masks_draw_path_seg_by_seg(cr, mask_gui, index, gui_points->points, gui_points->points_count,
                                  node_count, zoom_scale, TRUE);
  }
 
  if(0)
  {
    const int total_points = gui_points->points_count * 2;
    int seg1 = 1;
    int current_seg = 0;
 
    /* Draw the line point-by-point up to the next node, then stroke it; repeat in a loop. */
    cairo_move_to(cr, gui_points->points[node_count * 6], gui_points->points[node_count * 6 + 1]);
 
    const int end_idx = 0.5 * gui_points->points_count;
 
    for(int i = node_count * 3; i < end_idx; i++)
    {
      const double x = gui_points->points[i * 2];
      const double y = gui_points->points[i * 2 + 1];
      cairo_line_to(cr, x, y);
 
      int seg_idx = seg1 * 6;
      if((seg_idx + 3) < total_points)
      {
        const double segment_x = gui_points->points[seg_idx + 2];
        const double segment_y = gui_points->points[seg_idx + 3];
 
        /* Is this point the next node? */
        if(x == segment_x && y == segment_y)
        {
          const gboolean seg_selected = (mask_gui->group_selected == index)
                                        && (selected_segment == current_seg);
          const gboolean all_selected = (mask_gui->group_selected == index)
                                        && !mask_gui->node_selected
                                        && !mask_gui->handle_selected
                                        && !mask_gui->handle_border_selected
                                        && !mask_gui->seg_selected
                                        && (mask_gui->form_selected || mask_gui->form_dragging);
          // creation mode: draw the current segment as round dotted line
          if(mask_gui->creation && current_seg == node_count - 2)
            dt_draw_stroke_line(DT_MASKS_DASH_ROUND, FALSE, cr, all_selected, zoom_scale, CAIRO_LINE_CAP_ROUND);
          else
            dt_draw_stroke_line(DT_MASKS_NO_DASH, FALSE, cr, (seg_selected || all_selected), zoom_scale, CAIRO_LINE_CAP_BUTT);
          seg1 = (seg1 + 1) % node_count;
          current_seg++;
        }
      }
    }
  }
 
  // draw nodes and attached stuff
  if(mask_gui->group_selected == index)
  {
    // draw borders
    if(gui_points->border && gui_points->border_count > node_count * 3 + 2)
    {
      dt_draw_shape_lines(mask_gui->dev, DT_MASKS_DASH_STICK, FALSE, cr, node_count, (mask_gui->border_selected), zoom_scale,
                          gui_points->border, gui_points->border_count, &dt_masks_functions_brush.draw_shape,
                          CAIRO_LINE_CAP_ROUND, gui_points->border_skips, gui_points->border_skip_count);
    }
 
    // draw the current node's handle if it's a curve node
    if(mask_gui->node_selected && selected_node >= 0 && selected_node < node_count
       && !dt_masks_node_is_cusp(gui_points, selected_node))
    {
      const int n = selected_node;
      float handle[2];
      _brush_ctrl2_to_handle(gui_points->points[n * 6 + 2], gui_points->points[n * 6 + 3],
                             gui_points->points[n * 6 + 4], gui_points->points[n * 6 + 5], &handle[0], &handle[1],
                             TRUE);
      const float pt[2] = { gui_points->points[n * 6 + 2], gui_points->points[n * 6 + 3] };
      const gboolean selected = (mask_gui->node_hovered == n || selected_handle == n || (mask_gui->handle_hovered == n));
      dt_draw_handle(cr, pt, zoom_scale, handle, selected, FALSE);
    }
 
    // draw all nodes
    for(int k = 0; k < node_count; k++)
    {
      const gboolean corner = dt_masks_node_is_cusp(gui_points, k);
      const float x = gui_points->points[k * 6 + 2];
      const float y = gui_points->points[k * 6 + 3];
      const gboolean selected = (k == mask_gui->node_hovered || k == mask_gui->node_dragging);
      const gboolean action = (k == selected_node);
 
      dt_draw_node(cr, corner, action, selected, zoom_scale, x, y);
    }
 
    // Draw the current node's border handle, if needed
    if(mask_gui->node_selected && selected_node >= 0 && selected_node < node_count)
    {
      const int edited = selected_node;
      const gboolean selected = (mask_gui->node_hovered == edited
                              || selected_handle_border == edited
                              || mask_gui->handle_border_hovered == edited);
      float handle[2] = { 0.0f, 0.0f };
      // Show the border handle on the opposite side from the curve handle
      if(_brush_get_border_handle_mirrored(gui_points, node_count, edited, &handle[0], &handle[1]))
      {
        dt_draw_handle(cr, NULL, zoom_scale, handle, selected, TRUE);
      }
    }
  }
 
  // Draw the source if needed
  if(gui_points->source && gui_points->source_count > node_count * 3 + 2)
  {
    dt_masks_gui_center_point_t center_pt;
    if(_brush_get_source_center(gui_points, node_count, &center_pt))
      dt_masks_draw_source(cr, mask_gui, index, node_count, zoom_scale, &center_pt,
                           &dt_masks_functions_brush.draw_shape);
 
    //draw the current node projection
    for(int k = 0; k < node_count; k++)
    {
      if(mask_gui->group_selected == index
         && (k == mask_gui->node_hovered || k == selected_node
             || (mask_gui->creation && k == node_count - 1)))
      {
        const int node_index = k * 6 + 2;
        const float proj[2] = { gui_points->source[node_index], gui_points->source[node_index + 1] };
        const gboolean selected = mask_gui->node_hovered == k;
        const gboolean squared = dt_masks_node_is_cusp(gui_points, k);
 
        dt_draw_handle(cr, NULL, zoom_scale, proj, selected, squared);
      }
    }
  }
}
 
static void _brush_bounding_box_raw(const float *const restrict points, const float *const restrict border,
                                    const int node_count, const int total_points, float *x_min, float *x_max,
                                    float *y_min, float *y_max)
{
  // now we want to find the area, so we search min/max points
  float min_x = FLT_MAX, max_x = FLT_MIN, min_y = FLT_MAX, max_y = FLT_MIN;
  __OMP_PARALLEL_FOR__(reduction(min : min_x, min_y) reduction(max : max_x, max_y)  if(total_points > 1000))
  // Skip control points and only consider actual polyline samples.
  for(int point_index = node_count * 3; point_index < total_points; point_index++)
  {
    // we look at the borders
    const float border_x = border[point_index * 2];
    const float border_y = border[point_index * 2 + 1];
    min_x = MIN(border_x, min_x);
    max_x = MAX(border_x, max_x);
    min_y = MIN(border_y, min_y);
    max_y = MAX(border_y, max_y);
    // we look at the brush too
    const float brush_x = points[point_index * 2];
    const float brush_y = points[point_index * 2 + 1];
    min_x = MIN(brush_x, min_x);
    max_x = MAX(brush_x, max_x);
    min_y = MIN(brush_y, min_y);
    max_y = MAX(brush_y, max_y);
  }
  *x_min = min_x;
  *x_max = max_x;
  *y_min = min_y;
  *y_max = max_y;
}
 
static void _brush_bounding_box(const float *const points, const float *const border, const int node_count,
                                const int total_points, int *width, int *height, int *offset_x, int *offset_y)
{
  float min_x = FLT_MAX, max_x = FLT_MIN, min_y = FLT_MAX, max_y = FLT_MIN;
  _brush_bounding_box_raw(points, border, node_count, total_points, &min_x, &max_x, &min_y, &max_y);
  *height = max_y - min_y + 4;
  *width = max_x - min_x + 4;
  *offset_x = min_x - 2;
  *offset_y = min_y - 2;
}
 
static int _get_area(const dt_iop_module_t *const module, dt_dev_pixelpipe_t *pipe,
                     const dt_dev_pixelpipe_iop_t *const piece,
                     dt_masks_form_t *const mask_form, int *width, int *height, int *offset_x, int *offset_y,
                     int include_source)
{
  if(IS_NULL_PTR(module)) return 1;
  // we get buffers for all points
  float *points = NULL, *border = NULL;
  int points_count, border_count;
  const dt_masks_distort_t pipe_dist = dt_masks_distort_for_pipe(pipe, module->dev);
  if(_brush_get_pts_border(module->dev, mask_form, module->iop_order, DT_DEV_TRANSFORM_DIR_BACK_INCL, &pipe_dist,
                           &points, &points_count, &border, &border_count, NULL, NULL, NULL, NULL, include_source) != 0)
  {
    dt_pixelpipe_cache_free_align(points);
    dt_pixelpipe_cache_free_align(border);
    return 1;
  }
 
  const guint node_count = g_list_length(mask_form->points);
  if(IS_NULL_PTR(points) || IS_NULL_PTR(border) || points_count <= (int)(node_count * 3) || border_count <= (int)(node_count * 3))
  {
    dt_pixelpipe_cache_free_align(points);
    dt_pixelpipe_cache_free_align(border);
    *width = 0;
  *height = 0;
  *offset_x = 0;
  *offset_y = 0;
    return 0;
  }
  _brush_bounding_box(points, border, node_count, points_count, width, height, offset_x, offset_y);
 
  dt_pixelpipe_cache_free_align(points);
  dt_pixelpipe_cache_free_align(border);
  return 0;
}
 
static dt_masks_raster_result_t _brush_get_source_area(dt_iop_module_t *module, dt_dev_pixelpipe_t *pipe,
                                  dt_dev_pixelpipe_iop_t *piece,
                                  dt_masks_form_t *mask_form, int *width, int *height, int *offset_x, int *offset_y)
{
  *width = 0;
  *height = 0;
  *offset_x = 0;
  *offset_y = 0;
  return dt_masks_raster_from_status(
      _get_area(module, pipe, piece, mask_form, width, height, offset_x, offset_y, 1));
}
 
static dt_masks_raster_result_t _brush_get_area(const dt_iop_module_t *const module, dt_dev_pixelpipe_t *pipe,
                           const dt_dev_pixelpipe_iop_t *const piece,
                           dt_masks_form_t *const mask_form, int *width, int *height, int *offset_x,
                           int *offset_y)
{
  *width = 0;
  *height = 0;
  *offset_x = 0;
  *offset_y = 0;
  return dt_masks_raster_from_status(
      _get_area(module, pipe, piece, mask_form, width, height, offset_x, offset_y, 0));
}
 
static void _brush_falloff(float *const restrict buffer, int segment_start[2], int segment_end[2],
                           int offset_x, int offset_y, int buffer_width, float fading, float density)
{
  // segment length
  const int segment_length = sqrt((segment_end[0] - segment_start[0]) * (segment_end[0] - segment_start[0])
                                  + (segment_end[1] - segment_start[1]) * (segment_end[1] - segment_start[1]))
                             + 1;
  const int solid_length = (int)segment_length * fading;
  const int soft_length = segment_length - solid_length;
 
  const float segment_dx = segment_end[0] - segment_start[0];
  const float segment_dy = segment_end[1] - segment_start[1];
  const float inv_length = 1.0f / (float)segment_length;
  const float inv_soft = (soft_length > 0) ? 1.0f / (float)soft_length : 0.0f;
 
  for(int step = 0; step < segment_length; step++)
  {
    // position
    const int x = (int)((float)step * segment_dx * inv_length) + segment_start[0] - offset_x;
    const int y = (int)((float)step * segment_dy * inv_length) + segment_start[1] - offset_y;
    const float opacity = density * ((step <= solid_length) ? 1.0f : 1.0f - (float)(step - solid_length) * inv_soft);
    const int buffer_index = y * buffer_width + x;
    buffer[buffer_index] = MAX(buffer[buffer_index], opacity);
    if(x > 0)
      buffer[buffer_index - 1] = MAX(buffer[buffer_index - 1], opacity); // avoid gaps from rounding
    if(y > 0)
      buffer[buffer_index - buffer_width] = MAX(buffer[buffer_index - buffer_width], opacity); // avoid gaps from rounding
  }
}
 
static dt_masks_raster_result_t _brush_get_mask(const dt_iop_module_t *const module, dt_dev_pixelpipe_t *pipe,
                           const dt_dev_pixelpipe_iop_t *const piece,
                           dt_masks_form_t *const mask_form,
                           float **buffer, int *width, int *height, int *offset_x, int *offset_y)
{
  *buffer = NULL;
  *width = 0;
  *height = 0;
  *offset_x = 0;
  *offset_y = 0;
  if(IS_NULL_PTR(module)) return DT_MASKS_RASTER_ERROR;
  double timer_start = 0.0;
  double timer_step_start = 0.0;
  if(dt_get_debug_flags() & DT_DEBUG_PERF) timer_start = timer_step_start = dt_get_wtime();
 
  // we get buffers for all points
  float *points = NULL, *border = NULL, *payload = NULL;
  int points_count, border_count, payload_count;
  const dt_masks_distort_t pipe_dist = dt_masks_distort_for_pipe(pipe, module->dev);
  if(_brush_get_pts_border(module->dev, mask_form, module->iop_order, DT_DEV_TRANSFORM_DIR_BACK_INCL, &pipe_dist,
                           &points, &points_count,
                               &border, &border_count, &payload, &payload_count, NULL, NULL, 0) != 0)
  {
    dt_pixelpipe_cache_free_align(points);
    dt_pixelpipe_cache_free_align(border);
    dt_pixelpipe_cache_free_align(payload);
    return DT_MASKS_RASTER_ERROR;
  }
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] brush points took %0.04f sec\n", mask_form->name,
             dt_get_wtime() - timer_step_start);
    timer_step_start = dt_get_wtime();
  }
 
  const guint node_count = g_list_length(mask_form->points);
  if(IS_NULL_PTR(points) || IS_NULL_PTR(border) || IS_NULL_PTR(payload) || points_count <= (int)(node_count * 3)
     || border_count <= (int)(node_count * 3))
  {
    dt_pixelpipe_cache_free_align(points);
    dt_pixelpipe_cache_free_align(border);
    dt_pixelpipe_cache_free_align(payload);
    *buffer = NULL;
    *width = 0;
  *height = 0;
  *offset_x = 0;
  *offset_y = 0;
    return DT_MASKS_RASTER_EMPTY;
  }
  const gboolean use_sparse = (pipe->mask_rasterization_step > 1);
  const int sparse_step = pipe->mask_rasterization_step;
  _brush_bounding_box(points, border, node_count, points_count, width, height, offset_x, offset_y);
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
    dt_print(DT_DEBUG_MASKS, "[masks %s] brush_fill min max took %0.04f sec\n", mask_form->name,
             dt_get_wtime() - timer_step_start);
 
  // we allocate the buffer
  const size_t buffer_size = (size_t)(*width) * (*height);
  // ensure that the buffer is zeroed, as the below code only fills in pixels in the falloff region
  *buffer = dt_pixelpipe_cache_alloc_align_float_cache(buffer_size, 0);
  if(IS_NULL_PTR(*buffer))
  {
    dt_pixelpipe_cache_free_align(points);
    dt_pixelpipe_cache_free_align(border);
    dt_pixelpipe_cache_free_align(payload);
    return DT_MASKS_RASTER_ERROR;
  }
  memset(*buffer, 0, sizeof(float) * buffer_size);
 
  // now we fill the falloff
  int segment_start[2], segment_end[2];
  int prev_start[2] = { 0, 0 };
  int prev_end[2] = { 0, 0 };
  float prev_payload[2] = { 0.0f, 0.0f };
  gboolean have_prev = FALSE;
 
  // Walk all border samples and stamp a falloff segment for each.
  for(int border_index = node_count * 3; border_index < border_count; border_index++)
  {
    segment_start[0] = points[border_index * 2];
    segment_start[1] = points[border_index * 2 + 1];
    segment_end[0] = border[border_index * 2];
    segment_end[1] = border[border_index * 2 + 1];
 
    if(use_sparse && have_prev
       && (prev_start[0] != segment_start[0] || prev_start[1] != segment_start[1]
           || prev_end[0] != segment_end[0] || prev_end[1] != segment_end[1]))
    {
      // In sparse mode (preview/thumbnail), interpolate missing segments to reduce holes.
      for(int step = 1; step < sparse_step; step++)
      {
        const float t = (float)step / (float)sparse_step;
        int interp_start[2] = { (int)floorf(prev_start[0] + t * (segment_start[0] - prev_start[0]) + 0.5f),
                                (int)floorf(prev_start[1] + t * (segment_start[1] - prev_start[1]) + 0.5f) };
        int interp_end[2] = { (int)floorf(prev_end[0] + t * (segment_end[0] - prev_end[0]) + 0.5f),
                              (int)floorf(prev_end[1] + t * (segment_end[1] - prev_end[1]) + 0.5f) };
        const float hard = prev_payload[0] + t * (payload[border_index * 2] - prev_payload[0]);
        const float dens = prev_payload[1] + t * (payload[border_index * 2 + 1] - prev_payload[1]);
        _brush_falloff(*buffer, interp_start, interp_end, *offset_x, *offset_y, *width, hard, dens);
      }
    }
 
    _brush_falloff(*buffer, segment_start, segment_end, *offset_x, *offset_y, *width,
                   payload[border_index * 2], payload[border_index * 2 + 1]);
 
    prev_start[0] = segment_start[0];
    prev_start[1] = segment_start[1];
    prev_end[0] = segment_end[0];
    prev_end[1] = segment_end[1];
    prev_payload[0] = payload[border_index * 2];
    prev_payload[1] = payload[border_index * 2 + 1];
    have_prev = TRUE;
  }
 
  dt_pixelpipe_cache_free_align(points);
  dt_pixelpipe_cache_free_align(border);
  dt_pixelpipe_cache_free_align(payload);
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
    dt_print(DT_DEBUG_MASKS, "[masks %s] brush fill buffer took %0.04f sec\n", mask_form->name,
             dt_get_wtime() - timer_start);
 
  return DT_MASKS_RASTER_OK;
}
 
static inline void _brush_falloff_roi(float *buffer, const int *segment_start, const int *segment_end,
                                      int buffer_width, int buffer_height, float fading, float density)
{
  // segment length (increase by 1 to avoid division-by-zero special case handling)
  const int segment_length = sqrt((segment_end[0] - segment_start[0]) * (segment_end[0] - segment_start[0])
                                  + (segment_end[1] - segment_start[1]) * (segment_end[1] - segment_start[1]))
                             + 1;
  const int solid_length = fading * segment_length;
 
  const float step_x = (float)(segment_end[0] - segment_start[0]) / (float)segment_length;
  const float step_y = (float)(segment_end[1] - segment_start[1]) / (float)segment_length;
 
  const int direction_x = step_x <= 0 ? -1 : 1;
  const int direction_y = step_y <= 0 ? -1 : 1;
  const int neighbor_offset_x = direction_x;
  const int neighbor_offset_y = direction_y * buffer_width;
 
  float cursor_x = segment_start[0];
  float cursor_y = segment_start[1];
 
  float opacity = density;
  const float opacity_step = density / (float)(segment_length - solid_length);
 
  const int start_x = segment_start[0], start_y = segment_start[1];
  const int end_x = segment_end[0], end_y = segment_end[1];
  if((start_x < 0 && end_x < 0) || (start_x >= buffer_width && end_x >= buffer_width)
     || (start_y < 0 && end_y < 0) || (start_y >= buffer_height && end_y >= buffer_height))
    return;
  const int fully_inside = (start_x >= 0 && start_x < buffer_width && end_x >= 0 && end_x < buffer_width
                            && start_y >= 0 && start_y < buffer_height && end_y >= 0
                            && end_y < buffer_height);
 
  for(int step = 0; step < segment_length; step++)
  {
    const int x = cursor_x;
    const int y = cursor_y;
 
    cursor_x += step_x;
    cursor_y += step_y;
    if(step > solid_length) opacity -= opacity_step;
 
    if(!fully_inside && (x < 0 || x >= buffer_width || y < 0 || y >= buffer_height)) continue;
 
    float *buf = buffer + (size_t)y * buffer_width + x;
 
    *buf = MAX(*buf, opacity);
    if(x + direction_x >= 0 && x + direction_x < buffer_width)
      buf[neighbor_offset_x] = MAX(buf[neighbor_offset_x], opacity); // avoid gaps from rounding
    if(y + direction_y >= 0 && y + direction_y < buffer_height)
      buf[neighbor_offset_y] = MAX(buf[neighbor_offset_y], opacity); // avoid gaps from rounding
  }
}
 
// build a stamp which can be combined with other shapes in the same group
// prerequisite: 'buffer' is all zeros
static dt_masks_raster_result_t _brush_get_mask_roi(const dt_iop_module_t *const module, dt_dev_pixelpipe_t *pipe,
                               const dt_dev_pixelpipe_iop_t *const piece,
                               dt_masks_form_t *const mask_form, const dt_iop_roi_t *roi, float *buffer,
                               dt_iop_roi_t *touched)
{
  dt_masks_touched_none(touched);
  if(IS_NULL_PTR(module)) return DT_MASKS_RASTER_ERROR;
  double timer_start = 0.0;
  double timer_step_start = 0.0;
  if(dt_get_debug_flags() & DT_DEBUG_PERF) timer_start = timer_step_start = dt_get_wtime();
 
  const int roi_offset_x = roi->x;
  const int roi_offset_y = roi->y;
  const int roi_width = roi->width;
  const int roi_height = roi->height;
  const float roi_scale = roi->scale;
  const gboolean use_sparse = (pipe->mask_rasterization_step > 1);
  const int sparse_step = pipe->mask_rasterization_step;
 
  // we get buffers for all points
  float *points = NULL, *border = NULL, *payload = NULL;
 
  int points_count, border_count, payload_count;
 
  const dt_masks_distort_t pipe_dist = dt_masks_distort_for_pipe(pipe, module->dev);
  if(_brush_get_pts_border(module->dev, mask_form, module->iop_order, DT_DEV_TRANSFORM_DIR_BACK_INCL, &pipe_dist,
                           &points, &points_count, &border, &border_count, &payload, &payload_count, NULL, NULL, 0) != 0)
  {
    dt_pixelpipe_cache_free_align(points);
    dt_pixelpipe_cache_free_align(border);
    dt_pixelpipe_cache_free_align(payload);
    return DT_MASKS_RASTER_ERROR;
  }
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] brush points took %0.04f sec\n", mask_form->name,
             dt_get_wtime() - timer_step_start);
    timer_step_start = dt_get_wtime();
  }
 
  const guint node_count = g_list_length(mask_form->points);
  if(IS_NULL_PTR(points) || IS_NULL_PTR(border) || IS_NULL_PTR(payload) || points_count <= (int)(node_count * 3)
     || border_count <= (int)(node_count * 3))
  {
    dt_pixelpipe_cache_free_align(points);
    dt_pixelpipe_cache_free_align(border);
    dt_pixelpipe_cache_free_align(payload);
    return DT_MASKS_RASTER_EMPTY;
  }
 
  // we shift and scale down brush and border
  // Shift/scale border samples into ROI space.
  for(int border_index = node_count * 3; border_index < border_count; border_index++)
  {
    const float border_x = border[2 * border_index];
    const float border_y = border[2 * border_index + 1];
    border[2 * border_index] = border_x * roi_scale - roi_offset_x;
    border[2 * border_index + 1] = border_y * roi_scale - roi_offset_y;
  }
 
  // Shift/scale centerline samples into ROI space.
  for(int point_index = node_count * 3; point_index < points_count; point_index++)
  {
    const float point_x = points[2 * point_index];
    const float point_y = points[2 * point_index + 1];
    points[2 * point_index] = point_x * roi_scale - roi_offset_x;
    points[2 * point_index + 1] = point_y * roi_scale - roi_offset_y;
  }
 
 
  float min_x = 0.0f, max_x = 0.0f, min_y = 0.0f, max_y = 0.0f;
  _brush_bounding_box_raw(points, border, node_count, points_count, &min_x, &max_x, &min_y, &max_y);
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] brush_fill min max took %0.04f sec\n", mask_form->name,
             dt_get_wtime() - timer_step_start);
    timer_step_start = dt_get_wtime();
  }
 
  // check if the path completely lies outside of roi -> we're done/mask remains empty
  if(max_x < 0 || max_y < 0 || min_x >= roi_width || min_y >= roi_height)
  {
    dt_pixelpipe_cache_free_align(points);
    dt_pixelpipe_cache_free_align(border);
    dt_pixelpipe_cache_free_align(payload);
    return DT_MASKS_RASTER_EMPTY;
  }
 
  // now we fill the falloff
  if(!use_sparse)
  {
    __OMP_PARALLEL_FOR__(if(border_count - node_count * 3 > 1000))
    // Stamp each border segment directly (full sampling).
    for(int border_index = node_count * 3; border_index < border_count; border_index++)
    {
      const int segment_start[] = { points[border_index * 2], points[border_index * 2 + 1] };
      const int segment_end[] = { border[border_index * 2], border[border_index * 2 + 1] };
 
      if(MAX(segment_start[0], segment_end[0]) < 0 || MIN(segment_start[0], segment_end[0]) >= roi_width
         || MAX(segment_start[1], segment_end[1]) < 0
         || MIN(segment_start[1], segment_end[1]) >= roi_height)
        continue;
 
      _brush_falloff_roi(buffer, segment_start, segment_end, roi_width, roi_height, payload[border_index * 2],
                         payload[border_index * 2 + 1]);
    }
  }
  else
  {
    int prev_start[2] = { 0, 0 };
    int prev_end[2] = { 0, 0 };
    float prev_payload[2] = { 0.0f, 0.0f };
    gboolean have_prev = FALSE;
 
    // Sparse mode: interpolate between consecutive segments to reduce artifacts.
    for(int border_index = node_count * 3; border_index < border_count; border_index++)
    {
      int segment_start[2] = { points[border_index * 2], points[border_index * 2 + 1] };
      int segment_end[2] = { border[border_index * 2], border[border_index * 2 + 1] };
 
      if(use_sparse && have_prev
         && (prev_start[0] != segment_start[0] || prev_start[1] != segment_start[1]
             || prev_end[0] != segment_end[0] || prev_end[1] != segment_end[1]))
      {
        for(int step = 1; step < sparse_step; step++)
        {
          const float t = (float)step / (float)sparse_step;
          int interp_start[2] = { (int)floorf(prev_start[0] + t * (segment_start[0] - prev_start[0]) + 0.5f),
                                  (int)floorf(prev_start[1] + t * (segment_start[1] - prev_start[1]) + 0.5f) };
          int interp_end[2] = { (int)floorf(prev_end[0] + t * (segment_end[0] - prev_end[0]) + 0.5f),
                                (int)floorf(prev_end[1] + t * (segment_end[1] - prev_end[1]) + 0.5f) };
          if(!(MAX(interp_start[0], interp_end[0]) < 0 || MIN(interp_start[0], interp_end[0]) >= roi_width
               || MAX(interp_start[1], interp_end[1]) < 0 || MIN(interp_start[1], interp_end[1]) >= roi_height))
          {
            const float hard = prev_payload[0] + t * (payload[border_index * 2] - prev_payload[0]);
            const float dens = prev_payload[1] + t * (payload[border_index * 2 + 1] - prev_payload[1]);
            _brush_falloff_roi(buffer, interp_start, interp_end, roi_width, roi_height, hard, dens);
          }
        }
      }
 
      if(!(MAX(segment_start[0], segment_end[0]) < 0 || MIN(segment_start[0], segment_end[0]) >= roi_width
           || MAX(segment_start[1], segment_end[1]) < 0
           || MIN(segment_start[1], segment_end[1]) >= roi_height))
        _brush_falloff_roi(buffer, segment_start, segment_end, roi_width, roi_height,
                           payload[border_index * 2], payload[border_index * 2 + 1]);
 
      prev_start[0] = segment_start[0];
      prev_start[1] = segment_start[1];
      prev_end[0] = segment_end[0];
      prev_end[1] = segment_end[1];
      prev_payload[0] = payload[border_index * 2];
      prev_payload[1] = payload[border_index * 2 + 1];
      have_prev = TRUE;
    }
  }
 
  dt_pixelpipe_cache_free_align(points);
  dt_pixelpipe_cache_free_align(border);
  dt_pixelpipe_cache_free_align(payload);
 
  /* Every stamp lies between a centreline sample and its border sample, and writes one extra
   * neighbour pixel in each direction to close rounding gaps -- hence the margin. */
  dt_masks_touched_set(touched, (int)floorf(min_x) - 2, (int)floorf(min_y) - 2, (int)ceilf(max_x) + 2,
                       (int)ceilf(max_y) + 2, roi_width, roi_height);
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] brush set falloff took %0.04f sec\n", mask_form->name,
             dt_get_wtime() - timer_step_start);
    dt_print(DT_DEBUG_MASKS, "[masks %s] brush fill buffer took %0.04f sec\n", mask_form->name,
             dt_get_wtime() - timer_start);
  }
 
  return DT_MASKS_RASTER_OK;
}
 
static void _brush_sanitize_config(dt_masks_type_t type)
{
  // nothing to do (yet?)
}
 
static void _brush_set_form_name(struct dt_masks_form_t *const mask_form, const size_t form_number)
{
  snprintf(mask_form->name, sizeof(mask_form->name), _("brush #%d"), (int)form_number);
}
 
static void _brush_set_hint_message(const dt_masks_form_gui_t *const mask_gui,
                                    const dt_masks_form_t *const mask_form,
                                    char *const restrict msgbuf, const size_t msgbuf_len)
{
  // Ordered like the hit test in dt_masks_find_closest_handle_common(): the innermost target
  // under the cursor is the one the next click will act on, so it is the one we describe.
  // Only gestures that cannot be discovered any other way -- what the wheel does is the user's
  // own mapping now (masks_gui.h), shown in the Drawn tab, so it is not repeated here.
  if(mask_gui->creation)
  {
    if(dt_masks_form_is_clone(mask_form))
      g_strlcat(msgbuf, _("<b>Set source</b>: Shift+Click"), msgbuf_len);
  }
  else if(mask_gui->source_selected)
    g_strlcat(msgbuf, _("<b>Move source</b>: Drag"), msgbuf_len);
  else if(mask_gui->handle_border_hovered >= 0)
    g_strlcat(msgbuf, _("<b>Node size</b>: Drag"), msgbuf_len);
  else if(mask_gui->handle_hovered >= 0)
    g_strlcat(msgbuf, _("<b>Node curvature</b>: Drag"), msgbuf_len);
  // The node operations below need the node to be selected, which the first click does.
  else if(mask_gui->node_hovered >= 0 && mask_gui->node_selected)
    g_strlcat(msgbuf, _("<b>Move node</b>: Drag, <b>Switch smooth/sharp</b>: Ctrl+Click\n"
                        "<b>Delete node</b>: Right-click or Del"), msgbuf_len);
  else if(mask_gui->node_hovered >= 0)
    g_strlcat(msgbuf, _("<b>Move node</b>: Drag, <b>Delete node</b>: Right-click"), msgbuf_len);
  else if(mask_gui->seg_hovered >= 0 || mask_gui->seg_selected)
    g_strlcat(msgbuf, _("<b>Move segment</b>: Drag, <b>Add node</b>: Ctrl+Click"), msgbuf_len);
  else if(mask_gui->form_selected || mask_gui->border_selected)
    g_strlcat(msgbuf, _("<b>Move</b>: Drag"), msgbuf_len);
}
 
static void _brush_duplicate_points(dt_develop_t *const dev, dt_masks_form_t *const base, dt_masks_form_t *const dest)
{
   // unused arg, keep compiler from complaining
  dt_masks_duplicate_points(base, dest, sizeof(dt_masks_node_brush_t));
}
 
static void _brush_initial_source_pos(struct dt_develop_t *dev, const float iwd, const float iht, float *x, float *y)
{
 
 
  float offset[2] = { 0.01f, 0.01f };
  dt_dev_coordinates_raw_norm_to_raw_abs(dev, offset, 1);
  *x = offset[0];
  *y = offset[1];
}
 
static void _brush_switch_node_callback(GtkWidget *widget, gpointer user_data)
{
  dt_masks_form_gui_t *mask_gui = (dt_masks_form_gui_t *)user_data;
  if(IS_NULL_PTR(mask_gui)) return;
 
  dt_iop_module_t *module = mask_gui->dev->gui_module;
  if(IS_NULL_PTR(module)) return;
 
  mask_gui->node_selected = TRUE;
  mask_gui->node_selected_idx = mask_gui->node_hovered;
 
  const int form_id = mask_gui->formid;
  dt_masks_form_t *selected_form = dt_masks_get_from_id(mask_gui->dev, form_id);
  if(IS_NULL_PTR(selected_form)) return;
  dt_masks_form_gui_points_t *gui_points
      = (dt_masks_form_gui_points_t *)g_list_nth_data(mask_gui->points, mask_gui->group_selected);
  const int node_index = dt_masks_gui_selected_node_index(mask_gui);
  dt_masks_node_brush_t *node
      = (dt_masks_node_brush_t *)g_list_nth_data(selected_form->points, node_index);
  if(IS_NULL_PTR(gui_points) || IS_NULL_PTR(node)) return;
  dt_masks_toggle_bezier_node_type(module, selected_form, mask_gui, mask_gui->group_selected, gui_points,
                                   node_index, node->node, node->ctrl1, node->ctrl2, &node->state);
}
 
static void _brush_reset_round_node_callback(GtkWidget *widget, gpointer user_data)
{
  dt_masks_form_gui_t *mask_gui = (dt_masks_form_gui_t *)user_data;
  if(IS_NULL_PTR(mask_gui)) return;
 
  dt_iop_module_t *module = mask_gui->dev->gui_module;
  if(IS_NULL_PTR(module)) return;
 
  mask_gui->node_selected = TRUE;
  mask_gui->node_selected_idx = mask_gui->node_hovered;
 
  const int form_id = mask_gui->formid;
  dt_masks_form_t *selected_form = dt_masks_get_from_id(mask_gui->dev, form_id);
  if(IS_NULL_PTR(selected_form)) return;
  dt_masks_form_gui_points_t *gui_points
      = (dt_masks_form_gui_points_t *)g_list_nth_data(mask_gui->points, mask_gui->group_selected);
  const int selected_handle = dt_masks_gui_selected_handle_index(mask_gui);
  const int node_index = MAX(mask_gui->node_hovered, selected_handle);
  dt_masks_node_brush_t *node
      = (dt_masks_node_brush_t *)g_list_nth_data(selected_form->points, node_index);
  if(IS_NULL_PTR(gui_points) || IS_NULL_PTR(node)) return;
  dt_masks_reset_bezier_ctrl_points(module, selected_form, mask_gui, mask_gui->group_selected, gui_points,
                                    node_index, &node->state);
}
 
static void _brush_add_node_callback(GtkWidget *menu, gpointer user_data)
{
  dt_masks_form_gui_t *mask_gui = (dt_masks_form_gui_t *)user_data;
  if(IS_NULL_PTR(mask_gui)) return;
  dt_masks_form_t *visible_forms = dt_masks_get_visible_form(mask_gui->dev);
  if(IS_NULL_PTR(visible_forms)) return;
 
  dt_iop_module_t *module = mask_gui->dev->gui_module;
  if(IS_NULL_PTR(module)) return;
 
  dt_masks_form_group_t *group_entry = dt_masks_form_get_selected_group(visible_forms, mask_gui);
  if(IS_NULL_PTR(group_entry)) return;
  dt_masks_form_t *selected_form = dt_masks_get_from_id(mask_gui->dev, group_entry->formid);
  if(selected_form)
  {
    _add_node_to_segment(module, selected_form, group_entry->parentid, mask_gui, mask_gui->group_selected);
  }
 
  dt_dev_add_history_item(mask_gui->dev, module, TRUE, TRUE);
}
 
static int _brush_populate_context_menu(GtkWidget *menu, struct dt_masks_form_t *mask_form,
                                        struct dt_masks_form_gui_t *mask_gui,
                                        const float pointer_x, const float pointer_y)
{
  
  
  GtkWidget *menu_item = NULL;
  gchar *accel = g_strdup_printf(_("%s+Click"), gtk_accelerator_get_label(0, dt_accels_display_mods(DT_PRIMARY_MASK)));
 
  gboolean ret = FALSE;
 
  if(mask_gui->node_hovered >= 0)
  {
    dt_masks_form_gui_points_t *gui_points
        = (dt_masks_form_gui_points_t *)g_list_nth_data(mask_gui->points, mask_gui->group_selected);
    if(IS_NULL_PTR(gui_points)) goto end;
    dt_masks_node_brush_t *node
        = (dt_masks_node_brush_t *)g_list_nth_data(mask_form->points, mask_gui->node_hovered);
    if(IS_NULL_PTR(node)) goto end;
    const gboolean is_corner = dt_masks_node_is_cusp(gui_points, mask_gui->node_hovered);
 
    {
      gchar *to_change_type = g_strdup_printf(_("Switch to %s node"), (is_corner) ? _("round") : _("cusp"));
      const dt_menu_icon_t icon = is_corner ? DT_MENU_ICON_CIRCLE : DT_MENU_ICON_SQUARE;
      menu_item = ctx_gtk_menu_item_new_with_icon_and_shortcut(to_change_type, accel, menu,
                                                               _brush_switch_node_callback, mask_gui, icon);
      dt_free(to_change_type);
    }
 
    {
      menu_item = ctx_gtk_menu_item_new_with_markup(_("Reset round node"), menu,
                                                    _brush_reset_round_node_callback, mask_gui);
      gtk_widget_set_sensitive(menu_item, !is_corner && node->state != DT_MASKS_POINT_STATE_NORMAL);
    }
    ret = TRUE;
  }
 
  if(mask_gui->seg_selected)
  {
    menu_item = ctx_gtk_menu_item_new_with_markup_and_shortcut(_("Add a node here"), accel,
                                                               menu, _brush_add_node_callback, mask_gui);
    ret = TRUE;
  }
 
  end:
  dt_free(accel);
  return ret;
}
 
// The function table for brushes.  This must be public, i.e. no "static" keyword.
const dt_masks_functions_t dt_masks_functions_brush = {
  .point_struct_size = sizeof(struct dt_masks_node_brush_t),
  .sanitize_config = _brush_sanitize_config,
  .set_form_name = _brush_set_form_name,
  .set_hint_message = _brush_set_hint_message,
  .duplicate_points = _brush_duplicate_points,
  .initial_source_pos = _brush_initial_source_pos,
  .get_distance = _brush_get_distance,
  .get_points_border = _brush_get_points_border,
  .get_mask = _brush_get_mask,
  .get_mask_roi = _brush_get_mask_roi,
  .get_area = _brush_get_area,
  .get_source_area = _brush_get_source_area,
  .get_gravity_center = _brush_get_gravity_center,
  .get_interaction_value = _brush_get_interaction_value,
  .set_interaction_value = _brush_set_interaction_value,
  .update_hover = _find_closest_handle,
  .mouse_moved = _brush_events_mouse_moved,
  .mouse_scrolled = _brush_events_mouse_scrolled,
  .button_pressed = _brush_events_button_pressed,
  .button_released = _brush_events_button_released,
  .key_pressed = _brush_events_key_pressed,
  .post_expose = _brush_events_post_expose,
  .draw_shape = _brush_draw_shape,
  .init_ctrl_points = _brush_init_ctrl_points,
  .populate_context_menu = _brush_populate_context_menu
 
};
 
 
// 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