masks_functions.h

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2013-2014, 2016, 2019, 2021 Aldric Renaudin.
    Copyright (C) 2013, 2018, 2020-2021 Pascal Obry.
    Copyright (C) 2013 Simon Spannagel.
    Copyright (C) 2013-2014, 2016-2018 Tobias Ellinghaus.
    Copyright (C) 2013-2017, 2019-2020 Ulrich Pegelow.
    Copyright (C) 2014-2016 Roman Lebedev.
    Copyright (C) 2017-2019 Edgardo Hoszowski.
    Copyright (C) 2021 Hanno Schwalm.
    Copyright (C) 2021 Hubert Kowalski.
    Copyright (C) 2021 luzpaz.
    Copyright (C) 2021 Philipp Lutz.
    Copyright (C) 2021 Ralf Brown.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2023, 2025-2026 Aurélien PIERRE.
    Copyright (C) 2023 Luca Zulberti.
    Copyright (C) 2025 Alynx Zhou.
    Copyright (C) 2025-2026 Guillaume Stutin.
    
    darktable is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    darktable is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with darktable.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef DT_DEVELOP_MASKS_MASKS_FUNCTIONS_H
#define DT_DEVELOP_MASKS_MASKS_FUNCTIONS_H
 
#include "develop/masks.h"
#include "develop/masks_gui.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
typedef struct dt_masks_functions_t
{
  int point_struct_size;   // sizeof(struct dt_masks_point_*_t)
  void (*sanitize_config)(dt_masks_type_t type_flags);
  void (*set_form_name)(struct dt_masks_form_t *const form, const size_t nb);
  void (*set_hint_message)(const struct dt_masks_form_gui_t *const gui, const struct dt_masks_form_t *const form,
                           char *const __restrict__ msgbuf, const size_t msgbuf_len);
  void (*duplicate_points)(struct dt_develop_t *const dev, struct dt_masks_form_t *base, struct dt_masks_form_t *dest);
  void (*initial_source_pos)(struct dt_develop_t *dev, const float iwd, const float iht, float *x, float *y);
  // input coordinates are in absolute output-image space, dist is squared in the same space
  void (*get_distance)(float x, float y, float as, struct dt_masks_form_gui_t *gui, int index, int num_points,
                       int *inside, int *inside_border, int *near_handle, int *inside_source, float *dist);
  int (*get_points)(struct dt_develop_t *dev, float x, float y, float radius_a, float radius_b, float rotation,
                    float **points, int *points_count);
  dt_masks_raster_result_t (*get_points_border)(struct 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 *const module);
  dt_masks_raster_result_t (*get_mask)(const dt_iop_module_t *const module, const struct dt_dev_pixelpipe_t *pipe,
                  const dt_dev_pixelpipe_iop_t *const piece,
                  struct dt_masks_form_t *const form,
                  float **buffer, int *width, int *height, int *posx, int *posy);
  dt_masks_raster_result_t (*get_mask_roi)(const dt_iop_module_t *const fmodule, const struct dt_dev_pixelpipe_t *pipe,
                      const dt_dev_pixelpipe_iop_t *const piece,
                      struct dt_masks_form_t *const form,
                      const dt_iop_roi_t *roi, float *buffer, dt_iop_roi_t *touched);
  dt_masks_raster_result_t (*get_area)(const dt_iop_module_t *const module, const struct dt_dev_pixelpipe_t *pipe,
                  const dt_dev_pixelpipe_iop_t *const piece,
                  struct dt_masks_form_t *const form,
                  int *width, int *height, int *posx, int *posy);
  dt_masks_raster_result_t (*get_source_area)(const dt_iop_module_t *module, const struct dt_dev_pixelpipe_t *pipe,
                         const dt_dev_pixelpipe_iop_t *piece, struct dt_masks_form_t *form,
                         int *width, int *height, int *posx, int *posy);
  gboolean (*get_gravity_center)(struct dt_develop_t *dev, const struct dt_masks_form_t *form, float center[2], float *area);
  float (*get_interaction_value)(const struct dt_masks_form_t *form, dt_masks_interaction_t interaction);
  float (*set_interaction_value)(struct dt_masks_form_t *form, dt_masks_interaction_t interaction, float value,
                                 dt_masks_increment_t increment, int flow,
                                 struct dt_masks_form_gui_t *gui, struct dt_iop_module_t *module);
  /* Recompute hovered handles/nodes from the cached cursor state in gui. */
  int (*update_hover)(struct dt_masks_form_t *form, struct dt_masks_form_gui_t *gui, int index);
  /* Mouse x and y are widget-space coordinates from GTK/Cairo */
  int (*mouse_moved)(struct dt_iop_module_t *module, double x, double y, double pressure, int which,
                     struct dt_masks_form_t *form, int parentid, struct dt_masks_form_gui_t *gui, int index);
  /* Mouse x and y are widget-space coordinates from GTK/Cairo */
  int (*mouse_scrolled)(struct dt_iop_module_t *module, double x, double y, int up, const int delta_y, uint32_t state,
                        struct dt_masks_form_t *form, int parentid, struct dt_masks_form_gui_t *gui, int index,
                        dt_masks_interaction_t interaction);
  /* Mouse x and y are widget-space coordinates from GTK/Cairo */
  int (*button_pressed)(struct dt_iop_module_t *module, double x, double y,
                        double pressure, int which, int type, uint32_t state,
                        struct dt_masks_form_t *form, int parentid, struct dt_masks_form_gui_t *gui, int index);
  /* Mouse x and y are widget-space coordinates from GTK/Cairo */
  int (*button_released)(struct dt_iop_module_t *module, double x, double y, int which, uint32_t state,
                         struct dt_masks_form_t *form, int parentid, struct dt_masks_form_gui_t *gui, int index);
  /* Key event */
  int (*key_pressed)(struct dt_iop_module_t *module, GdkEventKey *event, struct dt_masks_form_t *form, int parentid, struct dt_masks_form_gui_t *gui, int index);
  void (*post_expose)(cairo_t *cr, float zoom_scale, struct dt_masks_form_gui_t *gui, int index, int num_points);
  // The function to draw the shape in question. Signature must match shape_draw_function_t.
  shape_draw_function_t draw_shape;
  void (*init_ctrl_points)(struct dt_masks_form_t *form);
  int (*populate_context_menu)(GtkWidget *menu, struct dt_masks_form_t *form, struct dt_masks_form_gui_t *gui, const float pzx, const float pzy);
} dt_masks_functions_t;
 
/* Rasterisation entry points, dispatched only from inside the masks module: the group fold
 * calls get_mask_roi on its children, and the GUI outline builder calls get_points_border.
 * They were declared in the public header with no caller outside this directory. */
dt_masks_raster_result_t dt_masks_get_mask_roi(const dt_iop_module_t *const module, const 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);
 
/* The outline is sampled at the density the dev's GUI shows -- dt_masks_gui_outline_step(),
 * read by dt_masks_distort_for_gui() -- so that it is built at the density it is drawn and
 * hit-tested at. The brush and the polygon sample their curves, arcs and stamps at it; the
 * circle, the ellipse and the gradient have their own sampling. */
dt_masks_raster_result_t dt_masks_get_points_border(struct dt_develop_t *dev, 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, dt_iop_module_t *module);
 
int dt_masks_outline_boundary_skips(const float *const points, const float *const border, const int count,
                                    const int header, dt_masks_skip_range_t **skips_out);
gboolean dt_masks_outline_short_way(const float *const centre, const float *const from, const float *const to,
                                    const gboolean default_clockwise);
void dt_masks_outline_offset_along(const float *const centre, float dx, float dy, const float radius,
                                   float *const border);
 
#define DT_MASKS_OUTLINE_TILT_MAX 1.0f
 
void dt_masks_outline_envelope_offset(const float *centre, float dx, float dy, float radius, float radius_rate,
                                      float *out);
 
 
gboolean dt_masks_skip_contains(const dt_masks_skip_range_t *skips, const int skip_count, const int index);
 
 
typedef struct dt_masks_sample_grid_t
{
  int x0, y0;         // index of the first cell, in cells
  int width, height;  // number of cells
  int step;           // cell spacing, in output pixels
  int px, py;         // ROI origin, in output pixels
  float iscale;       // 1.0f / roi->scale
} dt_masks_sample_grid_t;
 
void dt_masks_points_bounding_box(const float *const points, const int num_points,
                                  int *width, int *height, int *posx, int *posy);
 
float *dt_masks_sample_grid_backtransform(const struct dt_dev_pixelpipe_t *pipe, const double iop_order,
                                          const dt_masks_sample_grid_t *const grid,
                                          const char *const shape, const char *const form_name);
 
 
int dt_masks_preview_add_clone_source(struct dt_masks_form_gui_t *gui,
                                      struct dt_masks_preview_buffers_t *preview);
 
int dt_masks_points_shift_to_source(struct dt_develop_t *dev, const struct dt_iop_module_t *module,
                                    float **points, int *points_count,
                                    const float xs, const float ys, const int first_shifted);
 
#define DT_MASKS_GRID_MAX_STEP 8
 
void dt_masks_sample_grid_interpolate(const float *const points, const dt_masks_sample_grid_t *const grid,
                                      float *const buffer, const int buf_width, const int buf_height,
                                      int *const endx, int *const endy);
int dt_masks_point_in_form_exact(const float *pts, int num_pts, const float *points,
                                 int points_start, int points_count,
                                 const dt_masks_skip_range_t *skips, int skip_count);
 
/* The raw membership-state mutator. Module-private on purpose: it takes a row by pointer and
 * cannot touch the group, so every external caller had to remember the copy-on-write dance and
 * most did not. Outside code goes through dt_masks_group_set_member_operation(), which owns it. */
void dt_masks_group_entry_apply_operation(struct dt_masks_form_group_t *pt,
                                          const dt_masks_state_t apply_state);
 
extern const dt_masks_functions_t dt_masks_functions_circle;
extern const dt_masks_functions_t dt_masks_functions_ellipse;
extern const dt_masks_functions_t dt_masks_functions_brush;
extern const dt_masks_functions_t dt_masks_functions_polygon;
extern const dt_masks_functions_t dt_masks_functions_gradient;
extern const dt_masks_functions_t dt_masks_functions_group;
 
/* Shared between masks.c (data/persistence) and masks_gui.c (interaction) since the
 * GUI half moved out; internal to the masks subsystem like everything here. */
void dt_masks_form_gui_points_free(gpointer data);
void _check_id(dt_develop_t *dev, dt_masks_form_t *mask_form);
void _set_group_name_from_module(dt_iop_module_t *module, dt_masks_form_t *group_form);
dt_masks_form_t *_group_create(dt_develop_t *develop, dt_iop_module_t *module, dt_masks_type_t group_type);
dt_masks_form_t *_group_from_module(dt_develop_t *develop, dt_iop_module_t *module);
int _find_in_group(dt_develop_t *dev, dt_masks_form_t *group_form, int form_id);
 
#ifdef __cplusplus
}
#endif
 
#endif // DT_DEVELOP_MASKS_MASKS_FUNCTIONS_H