ellipse.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2013, 2018-2022 Pascal Obry.
    Copyright (C) 2013-2017 Tobias Ellinghaus.
    Copyright (C) 2013-2014, 2016, 2019 Ulrich Pegelow.
    Copyright (C) 2014, 2016, 2021 Aldric Renaudin.
    Copyright (C) 2014-2017 Roman Lebedev.
    Copyright (C) 2017-2019 Edgardo Hoszowski.
    Copyright (C) 2018 johannes hanika.
    Copyright (C) 2019 Andreas Schneider.
    Copyright (C) 2019, 2023, 2025-2026 Aurélien PIERRE.
    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) 2022 luzpaz.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2023 Luca Zulberti.
    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/user_message.h"
#include "math/math.h"
#include "system/macros.h"
#include "system/openmp.h"
#include "common/logging.h"
#include "common/times.h"
#include "caches/pixelpipe_cache_alloc.h"
#include "common/conf.h"
#include "develop/imageop.h"
#include "develop/masks.h"
#include "develop/masks_gui.h"
#include "develop/masks/masks_functions.h"
#include "develop/masks/masks_touched.h"
#include "math/openmp_maths.h"
#include "widgets/accelerators.h"
 
 
#define FADING_MIN 0.0005f
#define FADING_MAX 1.0f
 
#define BORDER_MIN 0.00005f
#define BORDER_MAX 0.5f
 
#define RADIUS_CLONE_MIN 0.00005f
#define RADIUS_CLONE_MAX 0.5f
 
#define RADIUS_NON_CLONE_MIN 0.0005f
#define RADIUS_NON_CLONE_MAX 1.0f
 
static inline void _ellipse_point_transform(const float xref, const float yref, const float x, const float y,
                                            const float sinr, const float cosr, float *xnew, float *ynew)
{
  const float xtmp = (sinr * sinr + cosr * cosr) * (x - xref) + (cosr * sinr - cosr * sinr) * (y - yref);
  const float ytmp = (cosr * sinr - cosr * sinr) * (x - xref) + (sinr * sinr + cosr * cosr) * (y - yref);
 
  *xnew = xref + xtmp;
  *ynew = yref + ytmp;
}
 
/*
// Jordan's point in polygon test
static int _ellipse_cross_test(float x, float y, float *point_1, float *point_2)
{
  float x_b = point_1[0];
  float y_b = point_1[1];
  float x_c = point_2[0];
  float y_c = point_2[1];
 
  // Early exit : bounding box test
  float min_y = fminf(y_b, y_c);
  float max_y = fmaxf(y_b, y_c);
  if (y <= min_y || y > max_y) return 1;
 
  const float x_a = x;
  const float y_a = y;
 
  // special case : horizontal line
  if(y_a == y_b && y_b == y_c)
  {
    if((x_b <= x_a && x_a <= x_c) || (x_c <= x_a && x_a <= x_b))
      return 0;
    else
      return 1;
  }
 
  // order points b and c by y
  if(y_b > y_c)
  {
    float tmp;
    tmp = x_b, x_b = x_c, x_c = tmp;
    tmp = y_b, y_b = y_c, y_c = tmp;
  }
 
  if(y_a == y_b && x_a == x_b) return 0;
 
  if(y_a <= y_b || y_a > y_c) return 1;
 
  const float delta = (x_b - x_a) * (y_c - y_a) - (y_b - y_a) * (x_c - x_a);
 
  if(delta > 0)
    return -1;
  else if(delta < 0)
    return 1;
  else
    return 0;
}
 
static int _ellipse_point_in_polygon(float x, float y, float *points, int points_count)
{
  int t = -1;
 
  t *= _ellipse_cross_test(x, y, points + 2 * (points_count - 1), points);
 
  for(int i = 0; i < points_count - 2; i++)
    t *= _ellipse_cross_test(x, y, points + 2 * i, points + 2 * (i + 1));
 
  return t;
}
*/
 
// check if point is close to path - segment by segment
static int _ellipse_point_close_to_path(float x, float y, float mouse_radius, float *points, int points_count)
{
  float radius2 = mouse_radius * mouse_radius;
 
  const float lastx = points[2 * (points_count - 1)];
  const float lasty = points[2 * (points_count - 1) + 1];
 
  for(int i = 0; i < points_count; i++)
  {
    const float px = points[2 * i];
    const float py = points[2 * i + 1];
 
    const float r1 = x - lastx;
    const float r2 = y - lasty;
    const float r3 = px - lastx;
    const float r4 = py - lasty;
 
    const float d = r1 * r3 + r2 * r4;
    const float l = sqf(r3) + sqf(r4);
    const float p = d / l;
 
    float xx = 0.0f, yy = 0.0f;
 
    if(p < 0 || (px == lastx && py == lasty))
    {
      xx = lastx;
      yy = lasty;
    }
    else if(p > 1)
    {
      xx = px;
      yy = py;
    }
    else
    {
      xx = lastx + p * r3;
      yy = lasty + p * r4;
    }
 
    const float dx = x - xx;
    const float dy = y - yy;
 
    if(sqf(dx) + sqf(dy) < radius2) return 1;
  }
  return 0;
}
 
static void _ellipse_get_distance(float x, float y, float mouse_radius, dt_masks_form_gui_t *gui, int index,
                                  int num_points, int *inside, int *inside_border, int *near_handle,
                                  int *inside_source, float *dist)
{
  // initialise returned values
  *inside_source = 0;
  *inside = 0;
  *inside_border = 0;
  *near_handle = -1;
  *dist = FLT_MAX;
 
  dt_masks_form_gui_points_t *gpt = (dt_masks_form_gui_points_t *)g_list_nth_data(gui->points, index);
  if(IS_NULL_PTR(gpt)) 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(gpt, x, y, 2.0f * mouse_radius)) return;
 
  const float pt[2] = { x, y };
 
  // we first check if we are inside the source form
  if(gpt->source && gpt->source_count > 10)
  {
    if(dt_masks_point_in_form_exact(pt, 1, gpt->source, 10, gpt->source_count - 5, NULL, 0) >= 0)
    {
      *inside_source = 1;
      *inside = 1;
 
      // get the minial dist for center & control points
      float min_dist_norm = FLT_MAX;
      for(int k=0; k<5; k++)
      {
        const float center_dx = x - gpt->source[k * 2];
        const float center_dy = y - gpt->source[k * 2 + 1];
        const float dist2 = sqf(center_dx) + sqf(center_dy);
        min_dist_norm = fminf(min_dist_norm, dist2);
      }
      *dist = min_dist_norm;
      return;
    }
  }
 
  if(IS_NULL_PTR(gpt->points) || gpt->points_count <= 5 || !gpt->border || gpt->border_count <= 5) return;
 
  // distance from center
  const float center_dx = x - gpt->points[0];
  const float center_dy = y - gpt->points[1];
  *dist = sqf(center_dx) + sqf(center_dy);
 
  const gboolean close_to_border = _ellipse_point_close_to_path(x, y, mouse_radius * 1.5, gpt->border + 10, gpt->border_count - 5);
  const gboolean in_border = dt_masks_point_in_form_exact(pt, 1, gpt->border + 10, 10, gpt->border_count - 5, NULL, 0) >= 0;
  // we check if it's inside borders
  if(!close_to_border && !in_border) return;  
  *inside = 1;
 
  // and we check if it's inside form
  const int in_form = _ellipse_point_close_to_path(x, y, mouse_radius, gpt->points + 10, gpt->points_count - 5);
  *inside_border = !in_form;
}
 
typedef struct dt_masks_ellipse_creation_values_t
{
  float radius_a;
  float radius_b;
  float border;
  float rotation;
  int flags;
} dt_masks_ellipse_creation_values_t;
 
static void _ellipse_get_creation_values(const dt_masks_form_t *form, dt_masks_ellipse_creation_values_t *values)
{
  const gboolean use_spot_defaults = dt_masks_form_uses_spot_defaults(form);
  values->border = dt_conf_get_float(use_spot_defaults ? "plugins/darkroom/spots/ellipse/border"
                                                       : "plugins/darkroom/masks/ellipse/border");
  values->flags = dt_conf_get_int(use_spot_defaults ? "plugins/darkroom/spots/ellipse/flags"
                                                    : "plugins/darkroom/masks/ellipse/flags");
  values->radius_a = dt_conf_get_float(use_spot_defaults ? "plugins/darkroom/spots/ellipse/radius_a"
                                                         : "plugins/darkroom/masks/ellipse/radius_a");
  values->radius_b = dt_conf_get_float(use_spot_defaults ? "plugins/darkroom/spots/ellipse/radius_b"
                                                         : "plugins/darkroom/masks/ellipse/radius_b");
  values->rotation = dt_conf_get_float(use_spot_defaults ? "plugins/darkroom/spots/ellipse/rotation"
                                                         : "plugins/darkroom/masks/ellipse/rotation");
}
 
static void _ellipse_init_new(dt_masks_form_t *form, dt_masks_form_gui_t *gui, dt_masks_node_ellipse_t *ellipse)
{
  dt_masks_ellipse_creation_values_t values;
  dt_masks_gui_cursor_to_raw_norm(gui->dev, gui, ellipse->center);
  _ellipse_get_creation_values(form, &values);
 
  ellipse->radius[0] = values.radius_a;
  ellipse->radius[1] = values.radius_b;
  ellipse->border = values.border;
  ellipse->rotation = values.rotation;
  ellipse->flags = values.flags;
 
  if(dt_masks_form_is_clone(form))
    dt_masks_set_source_pos_initial_value(gui, form);
  else
    dt_masks_reset_source(form);
}
 
static int _ellipse_get_points(dt_develop_t *dev, float xx, float yy, float radius_a, float radius_b,
                               float rotation, float **points, int *points_count);
 
// Mirror the circle creation preview flow: gather defaults, build temp geometry once,
// and let the expose path only draw the returned buffers.
static int _ellipse_get_creation_preview(dt_masks_form_t *form, dt_masks_form_gui_t *gui,
                                         dt_masks_preview_buffers_t *preview)
{
  dt_masks_ellipse_creation_values_t values;
  _ellipse_get_creation_values(form, &values);
 
  const float border_a = (values.flags & DT_MASKS_ELLIPSE_PROPORTIONAL)
                             ? values.radius_a * (1.0f + values.border)
                             : values.radius_a + values.border;
  const float border_b = (values.flags & DT_MASKS_ELLIPSE_PROPORTIONAL)
                             ? values.radius_b * (1.0f + values.border)
                             : values.radius_b + values.border;
 
  float center[2];
  dt_masks_gui_cursor_to_raw_norm(gui->dev, gui, center);
 
  *preview = (dt_masks_preview_buffers_t){ 0 };
  int err = _ellipse_get_points(gui->dev, center[0], center[1], values.radius_a, values.radius_b,
                                values.rotation, &preview->points, &preview->points_count);
  if(!err && values.border > 0.0f)
    err = _ellipse_get_points(gui->dev, center[0], center[1], border_a, border_b, values.rotation,
                              &preview->border, &preview->border_count);
  
  if(!err && dt_masks_form_is_clone(form))
    err = dt_masks_preview_add_clone_source(gui, preview);
 
  if(err)
    dt_masks_preview_buffers_cleanup(preview);
  
  return err;
}
 
static float *_points_to_transform(dt_develop_t *dev, float xx, float yy, float radius_a, float radius_b,
                                   float rotation, float wd, float ht, int *points_count)
{
  // Calculate the rotation angle in radians
  const float v = (rotation / 180.0f) * M_PI;
 
  // Calculate the radii in pixels
  const float a = radius_a * MIN(wd, ht);
  const float b = radius_b * MIN(wd, ht);
 
  const float sinv = sinf(v);
  const float cosv = cosf(v);
 
  // Number of points for the ellipse (take every nth point, interpolation for the GUI)
  const int n = 10;
  const float lambda = (a - b) / (a + b);
  const int l = MAX(
      100, (int)((M_PI * (a + b)
                  * (1.0f + (3.0f * lambda * lambda) / (10.0f + sqrtf(4.0f - 3.0f * lambda * lambda)))) / n));
 
  // buffer allocations
  float *const restrict points = dt_pixelpipe_cache_alloc_align_float_cache((size_t)2 * (l + 5), 0);
  if(IS_NULL_PTR(points))
  {
    *points_count = 0;
    return 0;
  }
  *points_count = l + 5;
 
  // Center of the ellipse
  float center[2] = { xx, yy };
  dt_dev_coordinates_raw_norm_to_raw_abs(dev, center, 1);
  const float x = points[0] = center[0];
  const float y = points[1] = center[1];
 
  // Control points (main axes)
  points[2] = x + a * cosv;
  points[3] = y + a * sinv;
  points[4] = x - a * cosv;
  points[5] = y - a * sinv;
 
  points[6] = x - b * sinv;
  points[7] = y + b * cosv;
  points[8] = x + b * sinv;
  points[9] = y - b * cosv;
  __OMP_PARALLEL_FOR_SIMD__(if(l > 100) aligned(points:64))
  for(int i = 5; i < l + 5; i++)
  {
    const float alpha = (i - 5) * 2.0 * M_PI / (float)l;
    points[i * 2]     = x + a * cosf(alpha) * cosv - b * sinf(alpha) * sinv;
    points[i * 2 + 1] = y + a * cosf(alpha) * sinv + b * sinf(alpha) * cosv;
  }
 
  return points;
}
 
static int _ellipse_get_points_source(dt_develop_t *dev, float xx, float yy, float xs, float ys, float radius_a,
                                      float radius_b, float rotation, float **points, int *points_count,
                                      const dt_iop_module_t *module)
{
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  const float wd = geometry.raw_width;
  const float ht = geometry.raw_height;
 
  // compute the points of the target (center and circumference of ellipse)
  // we get the point in RAW image reference
  *points = _points_to_transform(dev, xx, yy, radius_a, radius_b, rotation, wd, ht, points_count);
  if(IS_NULL_PTR(*points)) return 1;
 
  return dt_masks_points_shift_to_source(dev, module, points, points_count, xs, ys, 5);
}
 
static int _ellipse_get_points(dt_develop_t *dev, float xx, float yy, float radius_a, float radius_b,
                               float rotation, float **points, int *points_count)
{
  const dt_dev_image_geometry_t geometry = dt_dev_geometry_snapshot(dev);
  const float wd = geometry.raw_width;
  const float ht = geometry.raw_height;
 
  *points = _points_to_transform(dev, xx, yy, radius_a, radius_b, rotation, wd, ht, points_count);
  if(IS_NULL_PTR(*points)) return 1;
 
  // and we transform them with all distorted modules
  if(!dt_dev_coordinates_raw_abs_to_image_abs(dev, *points, *points_count))
  {
    dt_pixelpipe_cache_free_align(*points);
    *points = NULL;
    *points_count = 0;
    return 1;
  }
 
  return 0;
}
 
static dt_masks_raster_result_t _ellipse_get_points_border(dt_develop_t *dev, struct dt_masks_form_t *form,
                                      float **points,
                                      int *points_count, float **border, int *border_count,
                                      dt_masks_skip_range_t **border_skips, int *border_skip_count,
                                      int 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;
 
  // No geometry: an empty outline is the correct result here, not a failure. See the circle.
  if(IS_NULL_PTR(form) || IS_NULL_PTR(form->points)) return DT_MASKS_RASTER_EMPTY;
  dt_masks_node_ellipse_t *ellipse = (dt_masks_node_ellipse_t *)((form->points)->data);
  if(IS_NULL_PTR(ellipse)) return DT_MASKS_RASTER_EMPTY;
  float x = 0.0f, y = 0.0f, a = 0.0f, b = 0.0f;
  x = ellipse->center[0], y = ellipse->center[1];
  a = ellipse->radius[0], b = ellipse->radius[1];
 
  if(source)
  {
    float xs = form->source[0], ys = form->source[1];
    return dt_masks_raster_from_status(
        _ellipse_get_points_source(dev, x, y, xs, ys, a, b, ellipse->rotation, points, points_count, module));
  }
  else
  {
    if(_ellipse_get_points(dev, x, y, a, b, ellipse->rotation, points, points_count) != 0)
      return DT_MASKS_RASTER_ERROR;
    if(!IS_NULL_PTR(border))
    {
      const int prop = ellipse->flags & DT_MASKS_ELLIPSE_PROPORTIONAL;
      return dt_masks_raster_from_status(
          _ellipse_get_points(dev, x, y, (prop ? a * (1.0f + ellipse->border) : a + ellipse->border),
                              (prop ? b * (1.0f + ellipse->border) : b + ellipse->border), ellipse->rotation,
                              border, border_count));
    }
    return DT_MASKS_RASTER_OK;
  }
}
 
static void _ellipse_node_position_cb(const dt_masks_form_gui_points_t *gui_points, int node_index,
                                      float *node_x, float *node_y, void *user_data)
{
  const float *nodes = gui_points->points;
  const float rotation = atan2f(nodes[3] - nodes[1], nodes[2] - nodes[0]);
  const float sinr = sinf(rotation);
  const float cosr = cosf(rotation);
  _ellipse_point_transform(nodes[0], nodes[1], nodes[node_index * 2], nodes[node_index * 2 + 1],
                           sinr, cosr, node_x, node_y);
}
 
static void _ellipse_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)
{
  _ellipse_get_distance(pointer_x, pointer_y, cursor_radius, mask_gui, form_index, 0, inside,
                        inside_border, near_handle, inside_source, dist);
}
 
static void _ellipse_post_select_cb(dt_masks_form_gui_t *mask_gui, int inside, int inside_border,
                                    int inside_source, void *user_data)
{
  mask_gui->pivot_selected = inside_border ? TRUE : FALSE; // cast to strict gboolean
}
 
static int _find_closest_handle(dt_masks_form_t *mask_form, dt_masks_form_gui_t *mask_gui, int form_index)
{
  if(mask_gui) mask_gui->pivot_selected = FALSE;
  return dt_masks_find_closest_handle_common(mask_form, mask_gui, form_index, 5,
                                             NULL, NULL, _ellipse_node_position_cb,
                                             _ellipse_distance_cb, _ellipse_post_select_cb, NULL);
}
 
static int _init_fading(dt_masks_form_t *form, const float amount, const dt_masks_increment_t increment, const int flow)
{
  dt_masks_get_set_conf_value_with_toast(form, "border", amount, FADING_MIN, FADING_MAX,
                                         increment, flow, _("Fading: %3.2f%%"), 100.0f);
  return 1;
}
 
static int _init_size(dt_masks_form_t *form, const float amount, const dt_masks_increment_t increment, const int flow)
{
  float mask_radius_a = dt_masks_get_set_conf_value(form, "radius_a", amount, FADING_MIN, FADING_MAX, increment, flow);
  float mask_radius_b = dt_masks_get_set_conf_value(form, "radius_b", amount, FADING_MIN, FADING_MAX, increment, flow);
  dt_toast_log(_("Size: %3.2f%%"), fmaxf(mask_radius_a, mask_radius_b) * 2.f * 100.f);
  return 1;
}
 
static int _init_opacity(dt_masks_form_t *form, const float amount, const dt_masks_increment_t increment, const int flow)
{
  dt_masks_get_set_conf_value_with_toast(form, "opacity", amount, 0.f, 1.f,
                                         increment, flow, _("Opacity: %3.2f%%"), 100.f);
  return 1;
}
 
static int _init_rotation(dt_masks_form_t *form, const float amount, const dt_masks_increment_t increment, const int flow)
{
  dt_masks_get_set_conf_value_with_toast(form, "rotation", amount, 0.f, 360.f,
                                         increment, flow, _("Rotation: %3.2f\302\260"), 1.0f);
  return 1;
}
 
static float _ellipse_get_interaction_value(const dt_masks_form_t *form, dt_masks_interaction_t interaction)
{
  if(IS_NULL_PTR(form) || IS_NULL_PTR(form->points)) return NAN;
  const dt_masks_node_ellipse_t *ellipse = (const dt_masks_node_ellipse_t *)(form->points)->data;
  if(IS_NULL_PTR(ellipse)) return NAN;
 
  switch(interaction)
  {
    case DT_MASKS_INTERACTION_SIZE:
      return fmaxf(ellipse->radius[0], ellipse->radius[1]);
    case DT_MASKS_INTERACTION_FADING:
      return ellipse->border;
    case DT_MASKS_INTERACTION_ROTATION:
      return ellipse->rotation;
    default:
      return NAN;
  }
}
 
static gboolean _ellipse_get_gravity_center(dt_develop_t *dev, const dt_masks_form_t *form, float center[2], float *area)
{
  if(IS_NULL_PTR(form) || IS_NULL_PTR(form->points) || IS_NULL_PTR(center) || IS_NULL_PTR(area)) return FALSE;
  const dt_masks_node_ellipse_t *ellipse = (const dt_masks_node_ellipse_t *)(form->points)->data;
  if(IS_NULL_PTR(ellipse)) return FALSE;
  center[0] = ellipse->center[0];
  center[1] = ellipse->center[1];
  *area = M_PI_F * ellipse->radius[0] * ellipse->radius[1];
  return TRUE;
}
 
static int _change_fading(dt_masks_form_t *form, dt_masks_form_gui_t *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 *form, dt_masks_form_gui_t *gui, struct dt_iop_module_t *module,
                        int index, const float amount, const dt_masks_increment_t increment, const int flow);
static int _change_rotation(dt_masks_form_t *form, dt_masks_form_gui_t *gui, struct dt_iop_module_t *module,
                            int index, const float amount, const dt_masks_increment_t increment, const int flow);
 
static float _ellipse_set_interaction_value(dt_masks_form_t *form, dt_masks_interaction_t interaction, float value,
                                            dt_masks_increment_t increment, int flow,
                                            dt_masks_form_gui_t *gui, struct dt_iop_module_t *module)
{
  if(IS_NULL_PTR(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(gui) && gui->group_selected >= 0) ? gui->group_selected : 0;
 
  switch(interaction)
  {
    case DT_MASKS_INTERACTION_SIZE:
      if(!_change_size(form, gui, module, index, value, increment, flow)) return NAN;
      return _ellipse_get_interaction_value(form, interaction);
    case DT_MASKS_INTERACTION_FADING:
      if(!_change_fading(form, gui, module, index, value, increment, flow)) return NAN;
      return _ellipse_get_interaction_value(form, interaction);
    case DT_MASKS_INTERACTION_ROTATION:
      if(!_change_rotation(form, gui, module, index, value, increment, flow)) return NAN;
      return _ellipse_get_interaction_value(form, interaction);
    default:
      return NAN;
  }
}
 
static int _change_fading(dt_masks_form_t *form, dt_masks_form_gui_t *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(form) || IS_NULL_PTR(form->points)) return 0;
  dt_masks_node_ellipse_t *ellipse = (dt_masks_node_ellipse_t *)(form->points)->data;
  if(IS_NULL_PTR(ellipse)) return 0;
 
  ellipse->border = CLAMPF(dt_masks_apply_increment(ellipse->border, amount, increment, flow),
                           FADING_MIN, FADING_MAX);
 
  _init_fading(form, amount, increment, flow);
 
  // we recreate the form points
  dt_masks_gui_form_create(form, gui, index, module);
 
  return 1;
}
 
static int _change_size(dt_masks_form_t *form, dt_masks_form_gui_t *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(form) || IS_NULL_PTR(form->points)) return 0;
  dt_masks_node_ellipse_t *ellipse = (dt_masks_node_ellipse_t *)(form->points)->data;
  if(IS_NULL_PTR(ellipse)) return 0;
 
  // Sanitize
  // do not exceed upper limit of 1.0 and lower limit of 0.004
  if(amount > 1.0f && (ellipse->border > 1.0f ))
    return 1;
 
  // adjust the sizes directly to avoid re-querying group/form
  ellipse->radius[0] = dt_masks_apply_increment(ellipse->radius[0], amount, increment, flow);
  ellipse->radius[1] = dt_masks_apply_increment(ellipse->radius[1], amount, increment, flow);
 
  _init_size(form, amount, DT_MASKS_INCREMENT_SCALE, flow);
 
  // we recreate the form points
  dt_masks_gui_form_create(form, gui, index, module);
 
  return 1;
}
 
static int _change_rotation(dt_masks_form_t *form, dt_masks_form_gui_t *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(form) || IS_NULL_PTR(form->points)) return 0;
  dt_masks_node_ellipse_t *ellipse = (dt_masks_node_ellipse_t *)(form->points)->data;
  if(IS_NULL_PTR(ellipse)) return 0;
 
  // Rotation
  int flow_increased = (flow > 1) ? (flow - 1) * 5 : flow;
  ellipse->rotation = dt_masks_apply_increment(ellipse->rotation, amount, increment, flow_increased);
 
  // Ensure the rotation value warps within the interval [0, 360)
  if(ellipse->rotation > 360.f) ellipse->rotation = fmodf(ellipse->rotation, 360.f);
  else if(ellipse->rotation < 0.f) ellipse->rotation = 360.f - fmodf(-ellipse->rotation, 360.f);
 
  _init_rotation(form, amount, DT_MASKS_INCREMENT_OFFSET, flow);
 
  // we recreate the form points
  dt_masks_gui_form_create(form, gui, index, module);
 
  return 1;
}
 
/* Shape handlers receive widget-space coordinates, while normalized output-image
 * coordinates come from `gui->rel_pos` and absolute output-image
 * coordinates come from `gui->pos`. */
static int _ellipse_events_mouse_scrolled(struct dt_iop_module_t *module, double x, double y, int up, const int flow,
                                          uint32_t state, dt_masks_form_t *form, int parentid,
                                          dt_masks_form_gui_t *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().
  if(gui->creation)
  {
    // Adjusting the creation values also previews them under the cursor.
    switch(interaction)
    {
      case DT_MASKS_INTERACTION_ROTATION:
        return _init_rotation(form, (up ? +0.2f : -0.2f), DT_MASKS_INCREMENT_OFFSET, flow);
      case DT_MASKS_INTERACTION_OPACITY:
        return _init_opacity(form, up ? +0.02f : -0.02f, DT_MASKS_INCREMENT_OFFSET, flow);
      case DT_MASKS_INTERACTION_FADING:
        return _init_fading(form, (up ? 1.03f : 0.97f), DT_MASKS_INCREMENT_SCALE, flow);
      case DT_MASKS_INTERACTION_SIZE:
        return _init_size(form, (up ? 1.03f : 0.97f), DT_MASKS_INCREMENT_SCALE, flow);
      default:
        return 0;
    }
  }
  else if(gui->form_selected)
  {
    switch(interaction)
    {
      case DT_MASKS_INTERACTION_ROTATION:
        return _change_rotation(form, gui, module, index, (up ? +0.2f : -0.2f), DT_MASKS_INCREMENT_OFFSET, flow);
      case DT_MASKS_INTERACTION_OPACITY:
        return dt_masks_form_change_opacity(gui->dev, form, parentid, up, flow);
      case DT_MASKS_INTERACTION_FADING:
        return _change_fading(form, gui, module, index, (up ? 1.02f : 0.98f), DT_MASKS_INCREMENT_SCALE, flow);
      case DT_MASKS_INTERACTION_SIZE:
        return _change_size(form, gui, module, index, (up ? 1.02f : 0.98f), DT_MASKS_INCREMENT_SCALE, flow);
      default:
        return 0;
    }
  }
 
  return 0;
}
 
static int _ellipse_events_button_pressed(struct dt_iop_module_t *module, double x, double y,
                                          double pressure, int which, int type, uint32_t state,
                                          dt_masks_form_t *form, int parentid, dt_masks_form_gui_t *gui,
                                          int index)
{
  if(gui->creation && which == 1
      && ((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(form->type & DT_MASKS_CLONE) dt_masks_set_source_pos_initial_state(gui, state);
      return 1;
    }
 
  else if(which == 1)
  {
    if(gui->creation)
    {
      dt_iop_module_t *crea_module = gui->creation_module;
      // we create the ellipse
      dt_masks_node_ellipse_t *ellipse = (dt_masks_node_ellipse_t *)(malloc(sizeof(dt_masks_node_ellipse_t)));
      if(IS_NULL_PTR(ellipse)) return 0;
      _ellipse_init_new(form, gui, ellipse);
      form->points = g_list_append(form->points, ellipse);
      dt_masks_gui_form_save_creation(gui->dev, crea_module, form, gui);
      
      return 1;
    }
 
    else // creation is false
    {
      dt_masks_form_gui_points_t *gpt = (dt_masks_form_gui_points_t *)g_list_nth_data(gui->points, index);
      if(IS_NULL_PTR(gpt)) return 0;
      
      if(gui->source_selected && gui->edit_mode == DT_MASKS_EDIT_FULL)
      {
        // we start the source dragging
        gui->delta[0] = gpt->source[0] - gui->pos[0];
        gui->delta[1] = gpt->source[1] - gui->pos[1];
        return 1;
      }
      else if(gui->node_hovered >= 1 && gui->edit_mode == DT_MASKS_EDIT_FULL)
      {
        // we start the point dragging
        gui->delta[0] = gpt->points[0] - gui->pos[0];
        gui->delta[1] = gpt->points[1] - gui->pos[1];
        return 1;
      }
      else if(gui->form_selected && gui->edit_mode == DT_MASKS_EDIT_FULL)
      {
        // we start the form dragging or rotating
        if(gui->border_selected)
          gui->form_rotating = TRUE;
        else if(dt_modifier_is(state, GDK_SHIFT_MASK))
          gui->border_toggling = TRUE;
        else
          ;
 
        // Pour la rotation: stocker position absolue du clic initial
        // Pour le drag: stocker décalage
        if(gui->form_rotating)
        {
          gui->delta[0] = gui->pos[0];
          gui->delta[1] = gui->pos[1];
        }
        else
        {
          gui->delta[0] = gpt->points[0] - gui->pos[0];
          gui->delta[1] = gpt->points[1] - gui->pos[1];
        }
        return 1;
      }
    }
  }
 
  return 0;
}
 
static int _ellipse_events_button_released(struct dt_iop_module_t *module, double x, double y, int which,
                                           uint32_t state, dt_masks_form_t *form, int parentid,
                                           dt_masks_form_gui_t *gui, int index)
{
  
  
  
  
  
  
  if(IS_NULL_PTR(form) || IS_NULL_PTR(form->points)) return 0;
 
  if(gui->form_dragging && gui->edit_mode == DT_MASKS_EDIT_FULL)
  {
    // we end the form dragging
    return 1;
  }
  else if(gui->border_toggling && gui->edit_mode == DT_MASKS_EDIT_FULL)
  {
    // we get the ellipse
    dt_masks_node_ellipse_t *ellipse = (dt_masks_node_ellipse_t *)((form->points)->data);
    if(IS_NULL_PTR(ellipse)) return 0;
 
    // we end the border toggling
    gui->border_toggling = FALSE;
 
    // toggle feathering type of border and adjust border radius accordingly
    if(ellipse->flags & DT_MASKS_ELLIPSE_PROPORTIONAL)
    {
      const float min_radius = fmin(ellipse->radius[0], ellipse->radius[1]);
      ellipse->border = ellipse->border * min_radius;
      ellipse->border = CLAMP(ellipse->border, 0.001f, 1.0f);
 
      ellipse->flags &= ~DT_MASKS_ELLIPSE_PROPORTIONAL;
    }
    else
    {
      const float min_radius = fmin(ellipse->radius[0], ellipse->radius[1]);
      ellipse->border = ellipse->border/min_radius;
      ellipse->border = CLAMP(ellipse->border, 0.001f/min_radius, 1.0f/min_radius);
 
      ellipse->flags |= DT_MASKS_ELLIPSE_PROPORTIONAL;
    }
 
    if(form->type & (DT_MASKS_CLONE|DT_MASKS_NON_CLONE))
    {
      dt_conf_set_int("plugins/darkroom/spots/ellipse/flags", ellipse->flags);
      dt_conf_set_float("plugins/darkroom/spots/ellipse/border", ellipse->border);
    }
    else
    {
      dt_conf_set_int("plugins/darkroom/masks/ellipse/flags", ellipse->flags);
      dt_conf_set_float("plugins/darkroom/masks/ellipse/border", ellipse->border);
    }
 
    // we recreate the form points
    dt_masks_gui_form_create(form, gui, index, module);
 
    // we save the new parameters
 
    return 1;
  }
  else if(gui->form_rotating && gui->edit_mode == DT_MASKS_EDIT_FULL)
  {
    // we end the form rotating
    gui->form_rotating = FALSE;
    return 1;
  }
  else if(gui->node_dragging >= 1 && gui->edit_mode == DT_MASKS_EDIT_FULL)
  {
    // we end the node dragging
    return 1;
  }
  else if(gui->source_dragging)
  {
    return 1;
  }
  return 0;
}
 
static int _ellipse_events_key_pressed(struct dt_iop_module_t *module, GdkEventKey *event, dt_masks_form_t *form,
                                              int parentid, dt_masks_form_gui_t *gui, int index)
{
  return 0;
}
 
static int _ellipse_events_mouse_moved(struct dt_iop_module_t *module, double x, double y,
                                       double pressure, int which, dt_masks_form_t *form, int parentid,
                                       dt_masks_form_gui_t *gui, int index)
{
  if(gui->creation)
  {
    // Let the cursor motion be redrawn as it moves in GUI
    return 1;
  }
 
  if(IS_NULL_PTR(form) || IS_NULL_PTR(form->points)) return 0;
 
  dt_masks_node_ellipse_t *ellipse = (dt_masks_node_ellipse_t *)((form->points)->data);
  if(IS_NULL_PTR(ellipse)) return 0;
 
  // we need the reference points
  dt_masks_form_gui_points_t *gpt = (dt_masks_form_gui_points_t *)g_list_nth_data(gui->points, index);
  if(IS_NULL_PTR(gpt)) return 0;
  
  if(gui->form_dragging || gui->source_dragging)
    {
    dt_develop_t *dev = gui->dev;
    // apply delta to the current mouse position
    float pts[2];
    dt_masks_gui_delta_to_raw_norm(dev, gui, pts);
 
    if(gui->form_dragging)
    {
      ellipse->center[0] = pts[0];
      ellipse->center[1] = pts[1];
    }
    else if(gui->source_dragging)
    {
      form->source[0] = pts[0];
      form->source[1] = pts[1];
    }
 
    // we recreate the form points
    dt_masks_gui_form_create(form, gui, index, module);
 
    return 1;
  }
 
  else if(gui->node_dragging >= 1)
  {
    const int k = gui->node_dragging;
 
    const float xref = gpt->points[0];
    const float yref = gpt->points[1];
    const float rx = gpt->points[k * 2] - xref;
    const float ry = gpt->points[k * 2 + 1] - yref;
    const float deltax = gui->pos[0] + gui->delta[0] - xref;
    const float deltay = gui->pos[1] + gui->delta[1] - yref;
 
    // we remap dx, dy to the right values, as it will be used in next movements
    gui->delta[0] = xref - gui->pos[0];
    gui->delta[1] = yref - gui->pos[1];
 
    const float r = dt_fast_hypotf(rx, ry);
    const float d = (rx * deltax + ry * deltay) / r;
    const float s = fmaxf(r > 0.0f ? (r + d) / r : 0.0f, 0.0f);
    
    if(k == 1 || k == 2)
    {
      ellipse->radius[0] = MAX(0.0002f, ellipse->radius[0] * s);
      if(form->type & (DT_MASKS_CLONE | DT_MASKS_NON_CLONE))
        dt_conf_set_float("plugins/darkroom/spots/ellipse/radius_a", ellipse->radius[0]);
      else
        dt_conf_set_float("plugins/darkroom/masks/ellipse/radius_a", ellipse->radius[0]);
    }
    else if(k == 3 || k == 4)
    {
      ellipse->radius[1] = MAX(0.0002f, ellipse->radius[1] * s);
      if(form->type & (DT_MASKS_CLONE | DT_MASKS_NON_CLONE))
        dt_conf_set_float("plugins/darkroom/spots/ellipse/radius_b", ellipse->radius[1]);
      else
        dt_conf_set_float("plugins/darkroom/masks/ellipse/radius_b", ellipse->radius[1]);
    }
 
    // we recreate the form points
    dt_masks_gui_form_create(form, gui, index, module);
 
    return 1;
  }
 
  // rotation of the ellipse with the mouse
  else if(gui->form_rotating)
  {
 
    const float origin_point[2] = { gpt->points[0], gpt->points[1] };
    const float angle = dt_masks_rotate_with_anchor(gui->dev, gui->pos, origin_point, gui);
 
    _change_rotation(form, gui, module, index, angle , DT_MASKS_INCREMENT_OFFSET, 1);
 
    // we recreate the form points
    dt_masks_gui_form_create(form, gui, index, module);
 
    return 1;
  }
  
  //if(gui->edit_mode != DT_MASKS_EDIT_FULL) return 0;
  return 0;
}
 
static void _ellipse_draw_shape(dt_develop_t *dev, cairo_t *cr, const float *points, const int points_count, const int nb, const gboolean border, const gboolean source,
                              const dt_masks_skip_range_t *skips, const int skip_count)
{
  /* An ellipse has no self-intersections, so it never carries an exclusion list -- these are the
   * shared shape_draw_function_t signature, not something to honour here. */
  (void)dev; (void)nb; (void)border; (void)source; (void)skips; (void)skip_count;
 
  /* Decimate to the device resolution, as the brush does; see dt_draw_min_emit_step(). */
  const double min_step = dt_draw_min_emit_step(cr);
  const double min_step2 = min_step * min_step;
  double last_x = points[10], last_y = points[11];
  cairo_move_to(cr, last_x, last_y);
  for(int t = 6; t < points_count; t++)
  {
    const double x = points[t * 2];
    const double y = points[t * 2 + 1];
    const double dx = x - last_x, dy = y - last_y;
    if((dx * dx + dy * dy) < min_step2) continue;
    cairo_line_to(cr, x, y);
    last_x = x; last_y = y;
  }
  cairo_close_path(cr);
}
 
static void _ellipse_draw_handles(const dt_masks_form_gui_t *gui, cairo_t *cr, const float zoom_scale,
                      dt_masks_form_gui_points_t *gpt, const int index)
{
  if(IS_NULL_PTR(gpt) || IS_NULL_PTR(gpt->points) || gpt->points_count < 5) return;
 
  const int selected_node = dt_masks_gui_selected_node_index(gui);
  const float *nodes = gpt->points;
  float x, y;
 
  const float r = atan2f(nodes[3] - nodes[1], nodes[2] - nodes[0]);
  const float sinr = sinf(r);
  const float cosr = cosf(r);
 
  for(int i = 1; i < 5; i++)
  {
    _ellipse_point_transform(nodes[0], nodes[1], nodes[i * 2], nodes[i * 2 + 1], sinr, cosr, &x, &y);
    const gboolean selected = (i == gui->node_hovered || i == gui->node_dragging);
    const gboolean action = (i == selected_node);
    dt_draw_node(cr, TRUE, action, selected, zoom_scale, x, y);
  }
}
 
static void _ellipse_events_post_expose(cairo_t *cr, float zoom_scale, dt_masks_form_gui_t *gui, int index,
                                        int num_points)
{
  // add a preview when creating an ellipse
  // in creation mode
  if(gui->creation)
  {
    dt_masks_form_t *form = dt_masks_get_visible_form(gui->dev);
    dt_masks_preview_buffers_t preview;
    if(_ellipse_get_creation_preview(form, gui, &preview)) return;
 
    dt_masks_draw_preview_shape(gui->dev, cr, zoom_scale, num_points, preview.points, preview.points_count,
                                preview.border, preview.border_count,
                                &dt_masks_functions_ellipse.draw_shape, CAIRO_LINE_CAP_BUTT,
                                CAIRO_LINE_CAP_ROUND, TRUE, FALSE);
 
 
    // draw a cross where the source will be created
    if(dt_masks_form_is_clone(form))
    {
      dt_masks_draw_source_preview(cr, zoom_scale, gui, gui->pos[0], gui->pos[1], gui->pos[0], gui->pos[1], FALSE);
      dt_masks_draw_preview_shape(gui->dev, cr, zoom_scale, num_points, preview.source_points, preview.points_count,
                                NULL, 0, &dt_masks_functions_ellipse.draw_shape, CAIRO_LINE_CAP_BUTT,
                                CAIRO_LINE_CAP_ROUND, FALSE, TRUE);
    }
 
    dt_masks_preview_buffers_cleanup(&preview);
    
    return;
  } // gui->creation
 
  dt_masks_form_gui_points_t *gpt = (dt_masks_form_gui_points_t *)g_list_nth_data(gui->points, index);
  if(IS_NULL_PTR(gpt)) return;
 
  // we draw the main shape
  const gboolean selected = (gui->group_selected == index) && (gui->form_selected || gui->form_dragging);
  if(gpt->points && gpt->points_count > 5)
    dt_draw_shape_lines(gui->dev, DT_MASKS_NO_DASH, FALSE, cr, num_points, selected, zoom_scale, gpt->points,
                        gpt->points_count, &dt_masks_functions_ellipse.draw_shape, CAIRO_LINE_CAP_BUTT, NULL, 0);
  
  if(gui->group_selected == index)
  {
    // we draw the borders
    if(gpt->border && gpt->border_count > 5)
      dt_draw_shape_lines(gui->dev, DT_MASKS_DASH_STICK, FALSE, cr, num_points, (gui->border_selected), zoom_scale, gpt->border,
                          gpt->border_count, &dt_masks_functions_ellipse.draw_shape, CAIRO_LINE_CAP_ROUND, NULL, 0);
 
    // draw handles
    _ellipse_draw_handles(gui, cr, zoom_scale, gpt, index);
  }
 
  //draw the center point
  if(gui->group_selected == index && gui->pivot_selected && gpt->points && gpt->points_count > 0)
    dt_draw_node(cr, FALSE, FALSE, (gui->form_rotating), zoom_scale, gpt->points[0], gpt->points[1]);
 
  // draw the source if any
  if(gpt->source && gpt->source_count > 10 && gpt->points && gpt->points_count > 0)
  {
    dt_masks_gui_center_point_t center_pt = { .main = { gpt->points[0], gpt->points[1] },
                                              .source = { gpt->source[0], gpt->source[1] }};
    dt_masks_draw_source(cr, gui, index, num_points, zoom_scale, &center_pt, &dt_masks_functions_ellipse.draw_shape);
  }
 
}
 
 
static void _fill_mask(const size_t numpoints, float *const bufptr, const float *const points,
                       const float *const center, const float a, const float b, const float ta, const float tb,
                       const float alpha, const size_t out_scale)
{
  const float a2 = a * a;
  const float b2 = b * b;
  const float ta2 = ta * ta;
  const float tb2 = tb * tb;
  const float cos_alpha = cosf(alpha);
  const float sin_alpha = sinf(alpha);
 
  // Determine the strength of the mask for each of the distorted points.  If inside the border of the ellipse,
  // the strength is always 1.0; if outside the falloff region, it is 0.0, and in between it falls off quadratically.
  // To compute this, we need to do the equivalent of projecting the vector from the center of the ellipse to the
  // given point until it intersect the ellipse and the outer edge of the falloff, respectively.  The ellipse can
  // be rotated, but we can compensate for that by applying a rotation matrix for the same rotation in the opposite
  // direction before projecting the vector.
  __OMP_PARALLEL_FOR_SIMD__(if(numpoints > 50000) aligned(points, bufptr : 64))
  for(size_t i = 0; i < numpoints; i++)
    {
      const float x = points[2 * i] - center[0];
      const float y = points[2 * i + 1] - center[1];
      // find the square of the distance from the center
      const float l2 = x * x + y * y;
      const float l = sqrtf(l2);
      // normalize the point's coordinate to form a unit vector, taking care not to divide by zero
      const float x_norm = l ? x / l : 0.0f;
      const float y_norm = l ? y / l : 1.0f;  // ensure we don't get 0 for both sine and cosine below
      // apply the rotation matrix
      const float x_rot = x_norm * cos_alpha + y_norm * sin_alpha;
      const float y_rot = -x_norm * sin_alpha + y_norm * cos_alpha;
      // at this point, x_rot = cos(v) and y_rot = sin(v) since they are on the unit circle; we need the squared values
      const float cosv2 = x_rot * x_rot;
      const float sinv2 = y_rot * y_rot;
 
      // project the rotated unit vector out to the ellipse and the outer border
      const float radius2 = a2 * b2 / (a2 * sinv2 + b2 * cosv2);
      const float total2 = ta2 * tb2 / (ta2 * sinv2 + tb2 * cosv2);
 
      // quadratic falloff between the ellipses's radius and the radius of the outside of the feathering
      // ratio = 0.0 at the outer border, >= 1.0 within the ellipse, negative outside the falloff
      const float ratio = (total2 - l2) / (total2 - radius2);
      // enforce 1.0 inside the ellipse and 0.0 outside the feathering
      const float f = CLIP(ratio);
      bufptr[i << out_scale] = f * f;
    }
}
 
static float *const _ellipse_points_to_transform(dt_develop_t *dev, const float center_x, const float center_y, const float dim1, const float dim2,
                                                 const float rotation, const float wd, const float ht, size_t *point_count)
{
 
  const float v1 = ((rotation) / 180.0f) * M_PI;
  const float v2 = ((rotation - 90.0f) / 180.0f) * M_PI;
  float a = 0.0f, b = 0.0f, v = 0.0f;
 
  if(dim1 >= dim2)
  {
    a = dim1;
    b = dim2;
    v = v1;
  }
  else
  {
    a = dim2;
    b = dim1;
    v = v2;
  }
 
  const float sinv = sinf(v);
  const float cosv = cosf(v);
 
  // how many points do we need ?
  const float lambda = (a - b) / (a + b);
  const int l = (int)(M_PI * (a + b)
                      * (1.0f + (3.0f * lambda * lambda) / (10.0f + sqrtf(4.0f - 3.0f * lambda * lambda))));
 
  // buffer allocation
  float *points = dt_pixelpipe_cache_alloc_align_float_cache((size_t) 2 * (l + 5), 0);
  if(IS_NULL_PTR(points))
    return NULL;
  *point_count = l + 5;
 
  // now we set the points - first the center
  float center[2] = { center_x, center_y };
  dt_dev_coordinates_raw_norm_to_raw_abs(dev, center, 1);
  const float x = points[0] = center[0];
  const float y = points[1] = center[1];
  // then the control node points (ends of semimajor/semiminor axes)
  points[2] = x + a * cosf(v);
  points[3] = y + a * sinf(v);
  points[4] = x - a * cosf(v);
  points[5] = y - a * sinf(v);
  points[6] = x + b * cosf(v - M_PI / 2.0f);
  points[7] = y + b * sinf(v - M_PI / 2.0f);
  points[8] = x - b * cosf(v - M_PI / 2.0f);
  points[9] = y - b * sinf(v - M_PI / 2.0f);
  // and finally the regularly-spaced points on the circumference
  for(int i = 5; i < l + 5; i++)
  {
    float alpha = (i - 5) * 2.0 * M_PI / (float)l;
    points[i * 2] = x + a * cosf(alpha) * cosv - b * sinf(alpha) * sinv;
    points[i * 2 + 1] = y + a * cosf(alpha) * sinv + b * sinf(alpha) * cosv;
  }
  return points;
}
 
static dt_masks_raster_result_t _ellipse_get_source_area(dt_iop_module_t *module, dt_dev_pixelpipe_t *pipe,
                                    dt_dev_pixelpipe_iop_t *piece,
                                    dt_masks_form_t *form, int *width, int *height, int *posx, int *posy)
{
  /* Every early exit below must leave the out-parameters defined: callers read them
   * whenever this reports anything but ERROR, and three of them used to report success
   * for a shape with no geometry while writing none of these. */
  *width = 0;
  *height = 0;
  *posx = 0;
  *posy = 0;
  if(IS_NULL_PTR(form) || IS_NULL_PTR(form->points)) return DT_MASKS_RASTER_EMPTY;
  // we get the ellipse values
  dt_masks_node_ellipse_t *ellipse = (dt_masks_node_ellipse_t *)((form->points)->data);
  if(IS_NULL_PTR(ellipse)) return DT_MASKS_RASTER_EMPTY;
  const float wd = pipe->iwidth, ht = pipe->iheight;
  const int prop = ellipse->flags & DT_MASKS_ELLIPSE_PROPORTIONAL;
  const float total[2] = { (prop ? ellipse->radius[0] * (1.0f + ellipse->border) : ellipse->radius[0] + ellipse->border) * MIN(wd, ht),
                           (prop ? ellipse->radius[1] * (1.0f + ellipse->border) : ellipse->radius[1] + ellipse->border) * MIN(wd, ht) };
 
  // next we compute the points to be transformed
  size_t point_count = 0;
  float *const restrict points
    = _ellipse_points_to_transform(module->dev, form->source[0], form->source[1], total[0], total[1], ellipse->rotation, wd, ht, &point_count);
  if (IS_NULL_PTR(points))
    return DT_MASKS_RASTER_ERROR;
 
  // and we transform them with all distorted modules
  if(!dt_dev_distort_transform_plus(pipe, module->iop_order, DT_DEV_TRANSFORM_DIR_BACK_INCL, points, point_count))
  {
    dt_pixelpipe_cache_free_align(points);
    return DT_MASKS_RASTER_ERROR;
  }
 
  // finally, find the extreme left/right and top/bottom points
  dt_masks_points_bounding_box(points, point_count, width, height, posx, posy);
  dt_pixelpipe_cache_free_align(points);
  return DT_MASKS_RASTER_OK;
}
 
static dt_masks_raster_result_t _ellipse_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 form,
                             int *width, int *height, int *posx, int *posy)
{
  *width = 0;
  *height = 0;
  *posx = 0;
  *posy = 0;
  if(IS_NULL_PTR(form) || IS_NULL_PTR(form->points)) return DT_MASKS_RASTER_EMPTY;
  // we get the ellipse values
  dt_masks_node_ellipse_t *ellipse = (dt_masks_node_ellipse_t *)((form->points)->data);
  if(IS_NULL_PTR(ellipse)) return DT_MASKS_RASTER_EMPTY;
  const float wd = pipe->iwidth, ht = pipe->iheight;
  const int prop = ellipse->flags & DT_MASKS_ELLIPSE_PROPORTIONAL;
  const float total[2] = { (prop ? ellipse->radius[0] * (1.0f + ellipse->border) : ellipse->radius[0] + ellipse->border) * MIN(wd, ht),
                           (prop ? ellipse->radius[1] * (1.0f + ellipse->border) : ellipse->radius[1] + ellipse->border) * MIN(wd, ht) };
 
  // next we compute the points to be transformed
  size_t point_count = 0;
  float *const restrict points
    = _ellipse_points_to_transform(module->dev, ellipse->center[0], ellipse->center[1], total[0], total[1], ellipse->rotation, wd, ht, &point_count);
  if (IS_NULL_PTR(points))
    return DT_MASKS_RASTER_ERROR;
 
  // and we transform them with all distorted modules
  if(!dt_dev_distort_transform_plus(pipe, module->iop_order, DT_DEV_TRANSFORM_DIR_BACK_INCL, points, point_count))
  {
    dt_pixelpipe_cache_free_align(points);
    return DT_MASKS_RASTER_ERROR;
  }
 
  // finally, find the extreme left/right and top/bottom points
  dt_masks_points_bounding_box(points, point_count, width, height, posx, posy);
  dt_pixelpipe_cache_free_align(points);
  return DT_MASKS_RASTER_OK;
}
 
static dt_masks_raster_result_t _ellipse_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 form,
                             float **buffer, int *width, int *height, int *posx, int *posy)
{
  *buffer = NULL;
  *width = 0;
  *height = 0;
  *posx = 0;
  *posy = 0;
  if(IS_NULL_PTR(form) || IS_NULL_PTR(form->points)) return DT_MASKS_RASTER_EMPTY;
  double start2 = 0.0;
  if(dt_get_debug_flags() & DT_DEBUG_PERF) start2 = dt_get_wtime();
 
  // we get the area
  const dt_masks_raster_result_t area = _ellipse_get_area(module, pipe, piece, form, width, height, posx, posy);
  if(area != DT_MASKS_RASTER_OK) return area;
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] ellipse area took %0.04f sec\n", form->name, dt_get_wtime() - start2);
    start2 = dt_get_wtime();
  }
 
  // we get the ellipse values
  dt_masks_node_ellipse_t *ellipse = (dt_masks_node_ellipse_t *)((form->points)->data);
  if(IS_NULL_PTR(ellipse)) return DT_MASKS_RASTER_EMPTY;
  // we create a buffer of points with all points in the area
  int w = *width, h = *height;
  const int posx_ = *posx;
  const int posy_ = *posy;
  float *points = dt_pixelpipe_cache_alloc_align_float_cache((size_t)2 * w * h, 0);
  if(IS_NULL_PTR(points))
    return DT_MASKS_RASTER_ERROR;
  __OMP_PARALLEL_FOR__(collapse(2) if((size_t)w * h > 50000))
  for(int i = 0; i < h; i++)
    for(int j = 0; j < w; j++)
    {
      points[(i * w + j) * 2] = (j + posx_);
      points[(i * w + j) * 2 + 1] = (i + posy_);
    }
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] ellipse draw took %0.04f sec\n", form->name, dt_get_wtime() - start2);
    start2 = dt_get_wtime();
  }
 
  // we back transform all this points
  if(!dt_dev_distort_backtransform_plus(pipe, module->iop_order, DT_DEV_TRANSFORM_DIR_BACK_INCL, points, (size_t)w * h))
  {
    dt_pixelpipe_cache_free_align(points);
    return DT_MASKS_RASTER_ERROR;
  }
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] ellipse transform took %0.04f sec\n", form->name,
             dt_get_wtime() - start2);
    start2 = dt_get_wtime();
  }
 
  // we allocate the buffer
  *buffer = dt_pixelpipe_cache_alloc_align_float_cache((size_t)w * h, 0);
  if(IS_NULL_PTR(*buffer))
  {
    dt_pixelpipe_cache_free_align(points);
    return DT_MASKS_RASTER_ERROR;
  }
 
  // we populate the buffer
  const int wi = pipe->iwidth, hi = pipe->iheight;
  const float center[2] = { ellipse->center[0] * wi, ellipse->center[1] * hi };
  const float radius[2] = { ellipse->radius[0] * MIN(wi, hi), ellipse->radius[1] * MIN(wi, hi) };
  const float total[2] =  { (ellipse->flags & DT_MASKS_ELLIPSE_PROPORTIONAL ? ellipse->radius[0] * (1.0f + ellipse->border) : ellipse->radius[0] + ellipse->border) * MIN(wi, hi),
                            (ellipse->flags & DT_MASKS_ELLIPSE_PROPORTIONAL ? ellipse->radius[1] * (1.0f + ellipse->border) : ellipse->radius[1] + ellipse->border) * MIN(wi, hi) };
 
  float a = 0.0F, b = 0.0F, ta = 0.0F, tb = 0.0F, alpha = 0.0F;
 
  if(radius[0] >= radius[1])
  {
    a = radius[0];
    b = radius[1];
    ta = total[0];
    tb = total[1];
    alpha = (ellipse->rotation / 180.0f) * M_PI;
  }
  else
  {
    a = radius[1];
    b = radius[0];
    ta = total[1];
    tb = total[0];
    alpha = ((ellipse->rotation - 90.0f) / 180.0f) * M_PI;
  }
 
  float *const bufptr = *buffer;
 
  _fill_mask((size_t)(h)*w, bufptr, points, center, a, b, ta, tb, alpha, 0);
 
  dt_pixelpipe_cache_free_align(points);
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
    dt_print(DT_DEBUG_MASKS, "[masks %s] ellipse fill took %0.04f sec\n", form->name, dt_get_wtime() - start2);
 
  return DT_MASKS_RASTER_OK;
}
 
static dt_masks_raster_result_t _ellipse_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 form, const dt_iop_roi_t *roi, float *buffer,
                               dt_iop_roi_t *touched)
{
  dt_masks_touched_none(touched);
  if(IS_NULL_PTR(form) || IS_NULL_PTR(form->points)) return DT_MASKS_RASTER_EMPTY;
 
  double start1 = 0.0;
  double start2 = start1;
  if(dt_get_debug_flags() & DT_DEBUG_PERF) start2 = start1 = dt_get_wtime();
 
  // we get the ellipse parameters
  dt_masks_node_ellipse_t *ellipse = (dt_masks_node_ellipse_t *)((form->points)->data);
  if(IS_NULL_PTR(ellipse)) return DT_MASKS_RASTER_EMPTY;
  const int wi = pipe->iwidth, hi = pipe->iheight;
  const float center[2] = { ellipse->center[0] * wi, ellipse->center[1] * hi };
  const float radius[2] = { ellipse->radius[0] * MIN(wi, hi), ellipse->radius[1] * MIN(wi, hi) };
  const float total[2] = { (ellipse->flags & DT_MASKS_ELLIPSE_PROPORTIONAL ? ellipse->radius[0] * (1.0f + ellipse->border) : ellipse->radius[0] + ellipse->border) * MIN(wi, hi),
                           (ellipse->flags & DT_MASKS_ELLIPSE_PROPORTIONAL ? ellipse->radius[1] * (1.0f + ellipse->border) : ellipse->radius[1] + ellipse->border) * MIN(wi, hi) };
 
  const float a = radius[0];
  const float b = radius[1];
  const float ta = total[0];
  const float tb = total[1];
  const float alpha = (ellipse->rotation / 180.0f) * M_PI;
  const float cosa = cosf(alpha);
  const float sina = sinf(alpha);
 
  // we create a buffer of grid points for later interpolation: higher speed and reduced memory footprint;
  // we match size of buffer to bounding box around the shape
  const int w = roi->width;
  const int h = roi->height;
  const int px = roi->x;
  const int py = roi->y;
  const float iscale = 1.0f / roi->scale;
  // scale dependent resolution: when zoomed in (scale > 1), use finer grid to avoid interpolation holes
  const float grid_scale = 1.0f / MAX(roi->scale, 1e-6f);
  const int grid = CLAMP((10.0f * grid_scale + 2.0f) / 3.0f, 1, 4);
  const int gw = (w + grid - 1) / grid + 1;  // grid dimension of total roi
  const int gh = (h + grid - 1) / grid + 1;  // grid dimension of total roi
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] ellipse init took %0.04f sec\n", form->name, dt_get_wtime() - start2);
    start2 = dt_get_wtime();
  }
 
  // we look at the outer line of the shape - no effects outside of this ellipse;
  // we need many points as we do not know how the ellipse might get distorted in the pixelpipe
  const float lambda = (ta - tb) / (ta + tb);
  const int l = (int)(M_PI * (ta + tb) * (1.0f + (3.0f * lambda * lambda) / (10.0f + sqrtf(4.0f - 3.0f * lambda * lambda))));
  const size_t ellpts = MIN(360, l);
  float *ell = dt_pixelpipe_cache_alloc_align_float_cache(ellpts * 2, 0);
  if(IS_NULL_PTR(ell)) return DT_MASKS_RASTER_ERROR;
  __OMP_PARALLEL_FOR__(if(ellpts > 100))
  for(int n = 0; n < ellpts; n++)
  {
    const float phi = (2.0f * M_PI * n) / ellpts;
    const float cosp = cosf(phi);
    const float sinp = sinf(phi);
    ell[2 * n] = center[0] + ta * cosa * cosp - tb * sina * sinp;
    ell[2 * n + 1] = center[1] + ta * sina * cosp + tb * cosa * sinp;
  }
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] ellipse outline took %0.04f sec\n", form->name, dt_get_wtime() - start2);
    start2 = dt_get_wtime();
  }
 
  // we transform the outline from input image coordinates to current position in pixelpipe
  if(!dt_dev_distort_transform_plus(pipe, module->iop_order, DT_DEV_TRANSFORM_DIR_BACK_INCL, ell,
                                    ellpts))
  {
    dt_pixelpipe_cache_free_align(ell);
    return DT_MASKS_RASTER_ERROR;
  }
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] ellipse outline transform took %0.04f sec\n", form->name, dt_get_wtime() - start2);
    start2 = dt_get_wtime();
  }
 
  // we get the min/max values ...
  float xmin = FLT_MAX, ymin = FLT_MAX, xmax = FLT_MIN, ymax = FLT_MIN;
  for(int n = 0; n < ellpts; n++)
  {
    // just in case that transform throws surprising values
    if(!(isnormal(ell[2 * n]) && isnormal(ell[2 * n + 1]))) continue;
 
    xmin = MIN(xmin, ell[2 * n]);
    xmax = MAX(xmax, ell[2 * n]);
    ymin = MIN(ymin, ell[2 * n + 1]);
    ymax = MAX(ymax, ell[2 * n + 1]);
  }
 
#if 0
  printf("xmin %f, xmax %f, ymin %f, ymax %f\n", xmin, xmax, ymin, ymax);
  printf("wi %d, hi %d, iscale %f\n", wi, hi, iscale);
  printf("w %d, h %d, px %d, py %d\n", w, h, px, py);
#endif
 
  // ... and calculate the bounding box with a bit of reserve
  const int bbxm = CLAMP((int)floorf(xmin / iscale - px) / grid - 1, 0, gw - 1);
  const int bbXM = CLAMP((int)ceilf(xmax / iscale - px) / grid + 2, 0, gw - 1);
  const int bbym = CLAMP((int)floorf(ymin / iscale - py) / grid - 1, 0, gh - 1);
  const int bbYM = CLAMP((int)ceilf(ymax / iscale - py) / grid + 2, 0, gh - 1);
  const int bbw = bbXM - bbxm + 1;
  const int bbh = bbYM - bbym + 1;
 
#if 0
  printf("bbxm %d, bbXM %d, bbym %d, bbYM %d\n", bbxm, bbXM, bbym, bbYM);
  printf("gw %d, gh %d, bbw %d, bbh %d\n", gw, gh, bbw, bbh);
#endif
 
  dt_pixelpipe_cache_free_align(ell);
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] ellipse bounding box took %0.04f sec\n", form->name, dt_get_wtime() - start2);
    start2 = dt_get_wtime();
  }
 
  // check if there is anything to do at all;
  // only if width and height of bounding box is 2 or greater the shape lies inside of roi and requires action
  if(bbw <= 1 || bbh <= 1)
    return DT_MASKS_RASTER_EMPTY;
 
  const dt_masks_sample_grid_t sample_grid
      = { .x0 = bbxm, .y0 = bbym, .width = bbw, .height = bbh,
          .step = grid, .px = px, .py = py, .iscale = iscale };
  float *points
      = dt_masks_sample_grid_backtransform(pipe, module->iop_order, &sample_grid, "ellipse", form->name);
  if(IS_NULL_PTR(points)) return DT_MASKS_RASTER_ERROR;
  start2 = dt_get_wtime();
 
  // we calculate the mask values at the transformed points;
  // re-use the points array for results; this requires out_scale==1 to double the offsets at which they are stored
  _fill_mask((size_t)(bbh)*bbw, points, points, center, a, b, ta, tb, alpha, 1);
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] ellipse draw took %0.04f sec\n", form->name,
             dt_get_wtime() - start2);
    start2 = dt_get_wtime();
  }
 
  // we fill the pre-initialized output buffer by interpolation;
  // we only need to take the contents of our bounding box into account
  int endx = 0, endy = 0;
  dt_masks_sample_grid_interpolate(points, &sample_grid, buffer, w, h, &endx, &endy);
 
  dt_pixelpipe_cache_free_align(points);
 
  dt_masks_touched_set(touched, bbxm * grid, bbym * grid, endx - 1, endy - 1, w, h);
 
  if(dt_get_debug_flags() & DT_DEBUG_PERF)
  {
    dt_print(DT_DEBUG_MASKS, "[masks %s] ellipse fill took %0.04f sec\n", form->name, dt_get_wtime() - start2);
    dt_print(DT_DEBUG_MASKS, "[masks %s] ellipse total render took %0.04f sec\n", form->name,
             dt_get_wtime() - start1);
  }
  return DT_MASKS_RASTER_OK;
}
 
static void _ellipse_set_form_name(struct dt_masks_form_t *const form, const size_t nb)
{
  snprintf(form->name, sizeof(form->name), _("ellipse #%d"), (int)nb);
}
 
static void _ellipse_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_ellipse_t));
}
 
static void _ellipse_initial_source_pos(dt_develop_t *dev, const float iwd, const float iht, float *x, float *y)
{
 
 
  const float radius_a = dt_conf_get_float("plugins/darkroom/spots/ellipse/radius_a");
  const float radius_b = dt_conf_get_float("plugins/darkroom/spots/ellipse/radius_b");
  float offset[2] = { radius_a, -radius_b };
  dt_dev_coordinates_raw_norm_to_raw_abs(dev, offset, 1);
  *x = offset[0];
  *y = offset[1];
}
 
static void _ellipse_set_hint_message(const dt_masks_form_gui_t *const gui, const dt_masks_form_t *const form,
                                      char *const restrict msgbuf, const size_t msgbuf_len)
{
  // 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(gui->creation)
  {
    if(dt_masks_form_is_clone(form))
      g_strlcat(msgbuf, _("<b>Set source</b>: Shift+Click"), msgbuf_len);
  }
  else if(gui->source_selected)
    g_strlcat(msgbuf, _("<b>Move source</b>: Drag"), msgbuf_len);
  // Radius handles: the 4 axis nodes.
  else if(gui->node_hovered >= 1)
    g_strlcat(msgbuf, _("<b>Resize axis</b>: Drag"), msgbuf_len);
  // Clicking the border rotates instead of moving.
  else if(gui->border_selected)
    g_strlcat(msgbuf, _("<b>Rotate</b>: Drag"), msgbuf_len);
  else if(gui->form_selected)
    g_strlcat(msgbuf, _("<b>Move</b>: Drag, <b>Fading mode</b>: Shift+Click"), msgbuf_len);
}
 
static void _ellipse_sanitize_config(dt_masks_type_t type)
{
  int flags = -1;
  float radius_a = 0.0f;
  float radius_b = 0.0f;
  float border = 0.0f;
  if(type & (DT_MASKS_CLONE|DT_MASKS_NON_CLONE))
  {
    dt_conf_get_and_sanitize_float("plugins/darkroom/spots/ellipse/rotation", 0.0f, 360.f);
    flags = dt_conf_get_and_sanitize_int("plugins/darkroom/spots/ellipse/flags", DT_MASKS_ELLIPSE_EQUIDISTANT, DT_MASKS_ELLIPSE_PROPORTIONAL);
    radius_a = dt_conf_get_float("plugins/darkroom/spots/ellipse/radius_a");
    radius_b = dt_conf_get_float("plugins/darkroom/spots/ellipse/radius_b");
    border = dt_conf_get_float("plugins/darkroom/spots/ellipse/border");
  }
  else
  {
    dt_conf_get_and_sanitize_float("plugins/darkroom/masks/ellipse/rotation", 0.0f, 360.f);
    flags = dt_conf_get_and_sanitize_int("plugins/darkroom/masks/ellipse/flags", DT_MASKS_ELLIPSE_EQUIDISTANT, DT_MASKS_ELLIPSE_PROPORTIONAL);
    radius_a = dt_conf_get_float("plugins/darkroom/masks/ellipse/radius_a");
    radius_b = dt_conf_get_float("plugins/darkroom/masks/ellipse/radius_b");
    border = dt_conf_get_float("plugins/darkroom/masks/ellipse/border");
  }
 
  const float ratio = radius_a / radius_b;
 
  if(radius_a > radius_b)
  {
    radius_a = CLAMPS(radius_a, 0.001f, 0.5f);
    radius_b = radius_a / ratio;
  }
  else
  {
    radius_b = CLAMPS(radius_b, 0.001f, 0.5);
    radius_a = ratio * radius_b;
  }
 
  const float reference = (flags & DT_MASKS_ELLIPSE_PROPORTIONAL ? 1.0f / fmin(radius_a, radius_b) : 1.0f);
  border = CLAMPS(border, 0.001f * reference, reference);
 
  if(type & (DT_MASKS_CLONE|DT_MASKS_NON_CLONE))
  {
    DT_CONF_SET_SANITIZED_FLOAT("plugins/darkroom/spots/ellipse/radius_a", radius_a, 0.001f, 0.5f)
      DT_CONF_SET_SANITIZED_FLOAT("plugins/darkroom/spots/ellipse/radius_b", radius_b, 0.001f, 0.5f);
    DT_CONF_SET_SANITIZED_FLOAT("plugins/darkroom/spots/ellipse/border", border, 0.001f, reference);
  }
  else
  {
    DT_CONF_SET_SANITIZED_FLOAT("plugins/darkroom/masks/ellipse/radius_a", radius_a, 0.001f, 0.5f);
    DT_CONF_SET_SANITIZED_FLOAT("plugins/darkroom/masks/ellipse/radius_b", radius_b, 0.001f, 0.5f);
    DT_CONF_SET_SANITIZED_FLOAT("plugins/darkroom/masks/ellipse/border", border, 0.001f, reference);
  }
}
 
// The function table for ellipses.  This must be public, i.e. no "static" keyword.
const dt_masks_functions_t dt_masks_functions_ellipse = {
  .point_struct_size = sizeof(struct dt_masks_node_ellipse_t),
  .sanitize_config = _ellipse_sanitize_config,
  .set_form_name = _ellipse_set_form_name,
  .set_hint_message = _ellipse_set_hint_message,
  .duplicate_points = _ellipse_duplicate_points,
  .initial_source_pos = _ellipse_initial_source_pos,
  .get_distance = _ellipse_get_distance,
  .get_points = _ellipse_get_points,
  .get_points_border = _ellipse_get_points_border,
  .get_mask = _ellipse_get_mask,
  .get_mask_roi = _ellipse_get_mask_roi,
  .get_area = _ellipse_get_area,
  .get_source_area = _ellipse_get_source_area,
  .get_gravity_center = _ellipse_get_gravity_center,
  .get_interaction_value = _ellipse_get_interaction_value,
  .set_interaction_value = _ellipse_set_interaction_value,
  .update_hover = _find_closest_handle,
  .mouse_moved = _ellipse_events_mouse_moved,
  .mouse_scrolled = _ellipse_events_mouse_scrolled,
  .button_pressed = _ellipse_events_button_pressed,
  .button_released = _ellipse_events_button_released,
  .key_pressed = _ellipse_events_key_pressed,
  .post_expose = _ellipse_events_post_expose,
  .draw_shape = _ellipse_draw_shape
};
 
// 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