coordinates.c

Go to the documentation of this file.

/*
    This file is part of the Ansel project.
    Copyright (C) 2026 Aurélien PIERRE.
 
    Ansel 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.
 
    Ansel 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 Ansel.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#include "iop/drawlayer/coordinates.h"
 
static void _virtual_piece_input_offset(dt_iop_module_t *self, int *x, int *y)
{
  int ox = 0;
  int oy = 0;
 
  if(self && self->dev && self->dev->virtual_pipe)
  {
    dt_dev_pixelpipe_iop_t *piece = dt_dev_distort_get_iop_pipe(self->dev, self->dev->virtual_pipe, self);
    if(piece)
      dt_drawlayer_cache_resolve_piece_input_origin(piece, piece->pipe->iwidth, piece->pipe->iheight, &ox, &oy);
  }
 
  if(x) *x = ox;
  if(y) *y = oy;
}
 
gboolean dt_drawlayer_widget_points_to_layer_coords(dt_iop_module_t *self, float *pts, const int count)
{
  if(!self || !self->dev || !self->dev->virtual_pipe || !pts || count <= 0) return FALSE;
 
  dt_dev_coordinates_widget_to_image_norm(self->dev, pts, count);
  dt_dev_coordinates_image_norm_to_image_abs(self->dev, pts, count);
 
  if(!dt_dev_distort_backtransform_plus(self->dev, self->dev->virtual_pipe, self->iop_order,
                                        DT_DEV_TRANSFORM_DIR_FORW_EXCL, pts, count))
    return FALSE;
 
  int offset_x = 0;
  int offset_y = 0;
  _virtual_piece_input_offset(self, &offset_x, &offset_y);
  for(int i = 0; i < count; i++)
  {
    pts[2 * i] += offset_x;
    pts[2 * i + 1] += offset_y;
  }
 
  return TRUE;
}
 
gboolean dt_drawlayer_layer_points_to_widget_coords(dt_iop_module_t *self, float *pts, const int count)
{
  if(!self || !self->dev || !self->dev->virtual_pipe || !pts || count <= 0) return FALSE;
 
  int offset_x = 0;
  int offset_y = 0;
  _virtual_piece_input_offset(self, &offset_x, &offset_y);
  for(int i = 0; i < count; i++)
  {
    pts[2 * i] -= offset_x;
    pts[2 * i + 1] -= offset_y;
  }
 
  if(!dt_dev_distort_transform_plus(self->dev, self->dev->virtual_pipe, self->iop_order,
                                    DT_DEV_TRANSFORM_DIR_FORW_EXCL, pts, count))
    return FALSE;
 
  dt_dev_coordinates_image_abs_to_image_norm(self->dev, pts, count);
  dt_dev_coordinates_image_norm_to_widget(self->dev, pts, count);
  return TRUE;
}
 
gboolean dt_drawlayer_widget_to_layer_coords(dt_iop_module_t *self, const double wx, const double wy,
                                             float *lx, float *ly)
{
  if(!self || !self->dev || !self->dev->virtual_pipe || !lx || !ly) return FALSE;
 
  float pt[2] = { (float)wx, (float)wy };
  if(!dt_drawlayer_widget_points_to_layer_coords(self, pt, 1)) return FALSE;
 
  *lx = pt[0];
  *ly = pt[1];
  return TRUE;
}
 
gboolean dt_drawlayer_layer_to_widget_coords(dt_iop_module_t *self, const float x, const float y,
                                             float *wx, float *wy)
{
  if(!self || !self->dev || !self->dev->virtual_pipe || !wx || !wy) return FALSE;
 
  float pt[2] = { x, y };
  if(!dt_drawlayer_layer_points_to_widget_coords(self, pt, 1)) return FALSE;
  *wx = pt[0];
  *wy = pt[1];
  return TRUE;
}
 
gboolean dt_drawlayer_layer_bounds_to_widget_bounds(dt_iop_module_t *self, const float x0, const float y0,
                                                    const float x1, const float y1,
                                                    float *left, float *top,
                                                    float *right, float *bottom)
{
  if(!self || !self->dev || !self->dev->virtual_pipe) return FALSE;
 
  float pts[8] = {
    x0, y0, x1, y0, x0, y1, x1, y1,
  };
 
  if(!dt_drawlayer_layer_points_to_widget_coords(self, pts, 4)) return FALSE;
 
  float min_x = pts[0];
  float max_x = pts[0];
  float min_y = pts[1];
  float max_y = pts[1];
  for(int i = 1; i < 4; i++)
  {
    min_x = fminf(min_x, pts[2 * i]);
    max_x = fmaxf(max_x, pts[2 * i]);
    min_y = fminf(min_y, pts[2 * i + 1]);
    max_y = fmaxf(max_y, pts[2 * i + 1]);
  }
 
  if(left) *left = min_x;
  if(top) *top = min_y;
  if(right) *right = max_x;
  if(bottom) *bottom = max_y;
  return TRUE;
}
 
float dt_drawlayer_widget_brush_radius(dt_iop_module_t *self, const dt_drawlayer_brush_dab_t *dab,
                                       const float fallback)
{
  if(!self || !self->dev || !self->dev->virtual_pipe || !dab) return fallback;
 
  float pts[6] = {
    dab->x, dab->y, dab->x + dab->radius, dab->y, dab->x, dab->y + dab->radius,
  };
 
  if(!dt_drawlayer_layer_points_to_widget_coords(self, pts, 3)) return fallback;
 
  const float rx = hypotf(pts[2] - pts[0], pts[3] - pts[1]);
  const float ry = hypotf(pts[4] - pts[0], pts[5] - pts[1]);
  const float radius = 0.5f * (rx + ry);
  return fmaxf(0.5f, isfinite(radius) ? radius : fallback);
}
 
float dt_drawlayer_current_live_padding(dt_iop_module_t *self)
{
  dt_drawlayer_brush_dab_t dab = {
    .radius = fmaxf(_conf_size(), 0.5f),
    .hardness = _conf_hardness(),
    .shape = _conf_brush_shape(),
  };
  return ceilf(dab.radius + 1.0f);
}
 
gboolean dt_drawlayer_compute_view_patch(dt_iop_module_t *self, const float padding, drawlayer_view_patch_info_t *view)
{
  if(!self || !self->dev || !view) return FALSE;
 
  const int raw_width = self->dev->roi.raw_width;
  const int raw_height = self->dev->roi.raw_height;
  if(raw_width <= 0 || raw_height <= 0) return FALSE;
 
  const float widget_w = (float)self->dev->roi.orig_width;
  const float widget_h = (float)self->dev->roi.orig_height;
  const float preview_w = self->dev->roi.preview_width;
  const float preview_h = self->dev->roi.preview_height;
  if(widget_w <= 0.0f || widget_h <= 0.0f || preview_w <= 0.0f || preview_h <= 0.0f) return FALSE;
 
  const float zoom_scale = dt_dev_get_overlay_scale(self->dev);
  const float border = (float)self->dev->roi.border_size;
  const float roi_w = fminf(widget_w, preview_w * zoom_scale);
  const float roi_h = fminf(widget_h, preview_h * zoom_scale);
  const float rec_x = fmaxf(border, 0.5f * (widget_w - roi_w));
  const float rec_y = fmaxf(border, 0.5f * (widget_h - roi_h));
  const float rec_w = fminf(widget_w - 2.0f * border, roi_w);
  const float rec_h = fminf(widget_h - 2.0f * border, roi_h);
  if(rec_w <= 0.0f || rec_h <= 0.0f) return FALSE;
 
  float pts[8] = {
    rec_x, rec_y, rec_x + rec_w, rec_y, rec_x, rec_y + rec_h, rec_x + rec_w, rec_y + rec_h,
  };
  if(!dt_drawlayer_widget_points_to_layer_coords(self, pts, 4)) return FALSE;
 
  float min_x = pts[0];
  float max_x = pts[0];
  float min_y = pts[1];
  float max_y = pts[1];
  for(int i = 1; i < 4; i++)
  {
    min_x = fminf(min_x, pts[2 * i]);
    max_x = fmaxf(max_x, pts[2 * i]);
    min_y = fminf(min_y, pts[2 * i + 1]);
    max_y = fmaxf(max_y, pts[2 * i + 1]);
  }
 
  view->layer_x0 = min_x;
  view->layer_y0 = min_y;
  view->layer_x1 = max_x;
  view->layer_y1 = max_y;
 
  view->patch.x = MAX(0, (int)floorf(min_x - padding));
  view->patch.y = MAX(0, (int)floorf(min_y - padding));
  const int right = MIN(raw_width, (int)ceilf(max_x + padding));
  const int bottom = MIN(raw_height, (int)ceilf(max_y + padding));
  view->patch.width = MAX(0, right - view->patch.x);
  view->patch.height = MAX(0, bottom - view->patch.y);
  return view->patch.width > 0 && view->patch.height > 0;
}
 
gboolean dt_drawlayer_compute_process_patch_geometry(const dt_dev_pixelpipe_iop_t *piece,
                                                     const dt_iop_roi_t *roi_in,
                                                     const dt_iop_roi_t *roi_out,
                                                     const int base_width,
                                                     const int base_height,
                                                     const float brush_radius,
                                                     dt_drawlayer_process_patch_geometry_t *geometry)
{
  if(geometry) *geometry = (dt_drawlayer_process_patch_geometry_t){ 0 };
  if(!piece || !piece->pipe || !roi_out || !geometry || base_width <= 0 || base_height <= 0) return FALSE;
 
  geometry->process_roi = roi_in ? *roi_in : *roi_out;
  dt_drawlayer_cache_build_combined_process_roi_for_piece(piece, &geometry->process_roi,
                                                          piece->pipe->iwidth, piece->pipe->iheight,
                                                          base_width, base_height, &geometry->combined_roi);
  if(geometry->combined_roi.scale <= 1e-6f || roi_out->width <= 0 || roi_out->height <= 0) return FALSE;
 
  geometry->process_pad = MAX(0, (int)ceilf(fmaxf(brush_radius, 0.5f) * geometry->combined_roi.scale));
  geometry->padded_roi = geometry->combined_roi;
  geometry->padded_roi.x -= geometry->process_pad;
  geometry->padded_roi.y -= geometry->process_pad;
  geometry->padded_roi.width += 2 * geometry->process_pad;
  geometry->padded_roi.height += 2 * geometry->process_pad;
  geometry->patch_width = roi_out->width + 2 * geometry->process_pad;
  geometry->patch_height = roi_out->height + 2 * geometry->process_pad;
  return geometry->patch_width > 0 && geometry->patch_height > 0;
}