flip.c

Go to the documentation of this file.

/*
    This file is part of darktable,
    Copyright (C) 2011-2013, 2016 johannes hanika.
    Copyright (C) 2012 parafin.
    Copyright (C) 2012 Richard Wonka.
    Copyright (C) 2012-2014, 2016, 2018-2019 Tobias Ellinghaus.
    Copyright (C) 2012, 2014 Ulrich Pegelow.
    Copyright (C) 2013, 2020-2021 Aldric Renaudin.
    Copyright (C) 2013-2016 Roman Lebedev.
    Copyright (C) 2013 Simon Spannagel.
    Copyright (C) 2013 Thomas Pryds.
    Copyright (C) 2014 Dan Torop.
    Copyright (C) 2015, 2018-2022 Pascal Obry.
    Copyright (C) 2015 Pedro Côrte-Real.
    Copyright (C) 2017 Heiko Bauke.
    Copyright (C) 2018-2026 Aurélien PIERRE.
    Copyright (C) 2018 Edgardo Hoszowski.
    Copyright (C) 2018 Maurizio Paglia.
    Copyright (C) 2018 rawfiner.
    Copyright (C) 2019 Jacques Le Clerc.
    Copyright (C) 2020 Diederik Ter Rahe.
    Copyright (C) 2020 Marco.
    Copyright (C) 2020-2021 Ralf Brown.
    Copyright (C) 2022 Hanno Schwalm.
    Copyright (C) 2022 Martin Bařinka.
    Copyright (C) 2022 Philipp Lutz.
    Copyright (C) 2023 Alynx Zhou.
    Copyright (C) 2025 Guillaume Stutin.
    
    darktable is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    darktable is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with darktable.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "widgets/widget_settings.h"
#include "database/database.h"
#include "database/history_repository.h"
#include <assert.h>
#include "system/openmp.h"
#include "system/mem_alloc.h"
#include "common/logging.h"
#include "common/module_versioning.h"
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#include <inttypes.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
 
#include "imageio/imageio_core.h"
#include "common/opencl.h"
#include "develop/develop.h"
#include "develop/geometry/geometry.h"
#include "develop/imageop.h"
#include "develop/imageop_gui.h"
#include "develop/imageop_gui.h"
 
#include "gui/presets.h"
#include "iop/iop_api.h"
 
DT_MODULE_INTROSPECTION(2, dt_iop_flip_params_t)
 
typedef struct dt_iop_flip_params_t
{
  dt_image_orientation_t orientation;
} dt_iop_flip_params_t;
 
typedef struct dt_iop_flip_params_t dt_iop_flip_data_t;
 
typedef struct dt_iop_flip_global_data_t
{
  int kernel_flip;
} dt_iop_flip_global_data_t;
 
// helper to count corners in for loops:
static void get_corner(const int32_t *aabb, const int i, int32_t *p)
{
  for(int k = 0; k < 2; k++) p[k] = aabb[2 * ((i >> k) & 1) + k];
}
 
static void adjust_aabb(const int32_t *p, int32_t *aabb)
{
  aabb[0] = MIN(aabb[0], p[0]);
  aabb[1] = MIN(aabb[1], p[1]);
  aabb[2] = MAX(aabb[2], p[0]);
  aabb[3] = MAX(aabb[3], p[1]);
}
 
const char *name()
{
  return _("orientation");
}
 
const char *aliases()
{
  return _("rotation|flip");
}
 
int default_group()
{
  return IOP_GROUP_TECHNICAL;
}
 
int operation_tags()
{
  return IOP_TAG_DISTORT;
}
 
int flags()
{
  return IOP_FLAGS_ALLOW_TILING | IOP_FLAGS_TILING_FULL_ROI | IOP_FLAGS_ONE_INSTANCE | IOP_FLAGS_UNSAFE_COPY;
}
 
int default_colorspace(dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece)
{
  return IOP_CS_RGB;
}
 
const char **description(struct dt_iop_module_t *self)
{
  return dt_iop_set_description(self, _("flip or rotate image by step of 90 degrees"), _("corrective"),
                                _("linear, RGB, scene-referred"), _("geometric, RGB"),
                                _("linear, RGB, scene-referred"));
}
 
static dt_image_orientation_t merge_two_orientations(dt_image_orientation_t raw_orientation,
                                                     dt_image_orientation_t user_orientation)
{
  // Fast path: no coordinate swap needed
  if(!(user_orientation & ORIENTATION_SWAP_XY))
  {
    return raw_orientation ^ user_orientation;
  }
  
  // When user requests XY swap, we need to swap X/Y flip bits in raw orientation
  // Use bit manipulation for optimal performance
  dt_image_orientation_t corrected = raw_orientation;
  
  // Extract flip bits from raw orientation  
  const dt_image_orientation_t raw_flip_x = raw_orientation & ORIENTATION_FLIP_X;
  const dt_image_orientation_t raw_flip_y = raw_orientation & ORIENTATION_FLIP_Y;
  
  // Clear existing flip bits and set swapped versions
  corrected &= ~(ORIENTATION_FLIP_X | ORIENTATION_FLIP_Y);
  corrected |= (raw_flip_y << 1) | (raw_flip_x >> 1);  // Swap X↔Y bits efficiently
  
  // Preserve original XY swap bit if it was set
  corrected |= (raw_orientation & ORIENTATION_SWAP_XY);
  
  // Apply user transformation via XOR
  return corrected ^ user_orientation;
}
 
int legacy_params(dt_iop_module_t *self, const void *const old_params, const int old_version,
                  void *new_params, const int new_version)
{
  if(old_version == 1 && new_version == 2)
  {
    typedef struct dt_iop_flip_params_v1_t
    {
      int32_t orientation;
    } dt_iop_flip_params_v1_t;
 
    const dt_iop_flip_params_v1_t *old = (dt_iop_flip_params_v1_t *)old_params;
    dt_iop_flip_params_t *n = (dt_iop_flip_params_t *)new_params;
    const dt_iop_flip_params_t *d = (dt_iop_flip_params_t *)self->default_params;
 
    *n = *d; // start with a fresh copy of default parameters
 
    // we might be called from presets update infrastructure => there is no image
    dt_image_orientation_t image_orientation = ORIENTATION_NONE;
 
    if(self->dev)
      image_orientation = dt_image_orientation(&self->dev->image_storage);
 
    n->orientation = merge_two_orientations(image_orientation,
                                            (dt_image_orientation_t)(old->orientation));
 
    return 0;
  }
  return 1;
}
 
static void backtransform(const int32_t *x, int32_t *o, const dt_image_orientation_t orientation, int32_t iw,
                          int32_t ih)
{
  if(orientation & ORIENTATION_SWAP_XY)
  {
    o[1] = x[0];
    o[0] = x[1];
    const int32_t tmp = iw;
    iw = ih;
    ih = tmp;
  }
  else
  {
    o[0] = x[0];
    o[1] = x[1];
  }
  if(orientation & ORIENTATION_FLIP_X)
  {
    o[0] = iw - o[0] - 1;
  }
  if(orientation & ORIENTATION_FLIP_Y)
  {
    o[1] = ih - o[1] - 1;
  }
}
 
/* --- the shared geometry core ----------------------------------------------------------
 *
 * The ONE place flip's orientation is resolved and the ONE place its size map is expressed.
 * commit_params() and modify_roi_out() use them, and so does geometry_record() for the
 * pixel-less geometry service (develop/geometry/geometry.h).
 */
 
static dt_image_orientation_t _flip_resolve(dt_iop_module_t *self, const dt_iop_flip_params_t *const p)
{
  if(p->orientation == ORIENTATION_NULL) return dt_image_orientation(&self->dev->image_storage);
  return p->orientation;
}
 
static void _flip_map_size(const dt_image_orientation_t orientation, const dt_iop_roi_t *const roi_in,
                           dt_iop_roi_t *roi_out)
{
  *roi_out = *roi_in;
 
  // transform whole buffer roi
  if(orientation & ORIENTATION_SWAP_XY)
  {
    roi_out->width = roi_in->height;
    roi_out->height = roi_in->width;
  }
}
 
int distort_transform(dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece,
                      float *const restrict points, size_t points_count)
{
  // if (!self->enabled) return 2;
  const dt_iop_flip_data_t *d = (dt_iop_flip_data_t *)piece->data;
 
  // nothing to be done if parameters are set to neutral values (no flip or swap)
  if (d->orientation == 0) return 1;
  __OMP_PARALLEL_FOR__(if(points_count > 500))
  for(size_t i = 0; i < points_count * 2; i += 2)
  {
    float x = points[i];
    float y = points[i + 1];
    if(d->orientation & ORIENTATION_FLIP_X) x = piece->buf_in.width - points[i];
    if(d->orientation & ORIENTATION_FLIP_Y) y = piece->buf_in.height - points[i + 1];
    if(d->orientation & ORIENTATION_SWAP_XY)
    {
      const float yy = y;
      y = x;
      x = yy;
    }
    points[i] = x;
    points[i + 1] = y;
  }
 
  return 1;
}
int distort_backtransform(dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece,
                          float *const restrict points, size_t points_count)
{
  // if (!self->enabled) return 2;
  const dt_iop_flip_data_t *d = (dt_iop_flip_data_t *)piece->data;
 
  // nothing to be done if parameters are set to neutral values (no flip or swap)
  if (d->orientation == 0) return 1;
  __OMP_PARALLEL_FOR__(if(points_count > 500))
  for(size_t i = 0; i < points_count * 2; i += 2)
  {
    float x, y;
    if(d->orientation & ORIENTATION_SWAP_XY)
    {
      y = points[i];
      x = points[i + 1];
    }
    else
    {
      x = points[i];
      y = points[i + 1];
    }
    if(d->orientation & ORIENTATION_FLIP_X) x = piece->buf_in.width - x;
    if(d->orientation & ORIENTATION_FLIP_Y) y = piece->buf_in.height - y;
 
    points[i] = x;
    points[i + 1] = y;
  }
 
  return 1;
}
 
void distort_mask(struct dt_iop_module_t *self, const struct dt_dev_pixelpipe_t *pipe, struct dt_dev_pixelpipe_iop_t *piece,
                  const float *const in, float *const out, const dt_iop_roi_t *const roi_in,
                  const dt_iop_roi_t *const roi_out)
{
  (void)pipe;
  const dt_iop_flip_data_t *d = (dt_iop_flip_data_t *)piece->data;
 
  const int bpp = sizeof(float);
  const int stride = bpp * roi_in->width;
 
  dt_imageio_flip_buffers((char *)out, (const char *)in, bpp, roi_in->width, roi_in->height,
                          roi_in->width, roi_in->height, stride, d->orientation);
}
 
// 1st pass: how large would the output be, given this input roi?
// this is always called with the full buffer before processing.
void modify_roi_out(struct dt_iop_module_t *self, const struct dt_dev_pixelpipe_t *pipe,
                    struct dt_dev_pixelpipe_iop_t *piece, dt_iop_roi_t *roi_out,
                    const dt_iop_roi_t *roi_in)
{
  const dt_iop_flip_data_t *d = (dt_iop_flip_data_t *)piece->data;
  _flip_map_size(d->orientation, roi_in, roi_out);
}
 
// 2nd pass: which roi would this operation need as input to fill the given output region?
void modify_roi_in(struct dt_iop_module_t *self, const struct dt_dev_pixelpipe_t *pipe,
                   struct dt_dev_pixelpipe_iop_t *piece,
                   const dt_iop_roi_t *roi_out, dt_iop_roi_t *roi_in)
{
  const dt_iop_flip_data_t *d = (dt_iop_flip_data_t *)piece->data;
  *roi_in = *roi_out;
  // transform aabb back to roi_in
 
  // this aabb contains all valid points (thus the -1)
  int32_t p[2], o[2];
  int32_t aabb[4] = { roi_out->x, roi_out->y, roi_out->x + roi_out->width - 1, roi_out->y + roi_out->height - 1 };
  int32_t aabb_in[4] = { INT_MAX, INT_MAX, INT_MIN, INT_MIN };
  for(int c = 0; c < 4; c++)
  {
    // get corner points of roi_out
    get_corner(aabb, c, p);
    // backtransform aabb
    backtransform(p, o, d->orientation, piece->buf_out.width * roi_out->scale,
                  piece->buf_out.height * roi_out->scale);
    // transform to roi_in space, get aabb.
    adjust_aabb(o, aabb_in);
  }
 
  // adjust roi_in to minimally needed region
  roi_in->x = aabb_in[0];
  roi_in->y = aabb_in[1];
  // to convert valid points to widths, we need to add one
  roi_in->width = aabb_in[2] - aabb_in[0] + 1;
  roi_in->height = aabb_in[3] - aabb_in[1] + 1;
 
  // sanity check.
  float w = piece->buf_in.width * roi_out->scale;
  float h = piece->buf_in.height * roi_out->scale;
  roi_in->x = CLAMP(roi_in->x, 0, (int)floorf(w));
  roi_in->y = CLAMP(roi_in->y, 0, (int)floorf(h));
  roi_in->width = CLAMP(roi_in->width, 1, (int)ceilf(w) - roi_in->x);
  roi_in->height = CLAMP(roi_in->height, 1, (int)ceilf(h) - roi_in->y);
}
 
// 3rd (final) pass: you get this input region (may be different from what was requested above),
// do your best to fill the output region!
int process(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece, const void *const ivoid,
             void *const ovoid)
{
  const dt_iop_roi_t *const roi_in = &piece->roi_in;
  const dt_iop_flip_data_t *d = (dt_iop_flip_data_t *)piece->data;
 
  const int bpp = sizeof(float) * piece->dsc_in.channels;
  const int stride = bpp * roi_in->width;
 
  dt_imageio_flip_buffers((char *)ovoid, (const char *)ivoid, bpp, roi_in->width, roi_in->height,
                          roi_in->width, roi_in->height, stride, d->orientation);
  return 0;
}
 
#ifdef HAVE_OPENCL
int process_cl(struct dt_iop_module_t *self, const dt_dev_pixelpipe_t *pipe, const dt_dev_pixelpipe_iop_t *piece, cl_mem dev_in, cl_mem dev_out)
{
  const dt_iop_roi_t *const roi_in = &piece->roi_in;
  const dt_iop_flip_data_t *data = (dt_iop_flip_data_t *)piece->data;
  const dt_iop_flip_global_data_t *gd = (dt_iop_flip_global_data_t *)self->global_data;
  cl_int err = -999;
 
  const int devid = pipe->devid;
  const int width = roi_in->width;
  const int height = roi_in->height;
  const int orientation = data->orientation;
 
  const size_t sizes[] = { ROUNDUPDWD(width, devid), ROUNDUPDHT(height, devid), 1 };
 
  dt_opencl_set_kernel_arg(devid, gd->kernel_flip, 0, sizeof(cl_mem), (void *)&dev_in);
  dt_opencl_set_kernel_arg(devid, gd->kernel_flip, 1, sizeof(cl_mem), (void *)&dev_out);
  dt_opencl_set_kernel_arg(devid, gd->kernel_flip, 2, sizeof(int), (void *)&width);
  dt_opencl_set_kernel_arg(devid, gd->kernel_flip, 3, sizeof(int), (void *)&height);
  dt_opencl_set_kernel_arg(devid, gd->kernel_flip, 4, sizeof(int), (void *)&orientation);
  err = dt_opencl_enqueue_kernel_2d(devid, gd->kernel_flip, sizes);
 
  if(err != CL_SUCCESS) goto error;
  return TRUE;
 
error:
  dt_print(DT_DEBUG_OPENCL, "[opencl_flip] couldn't enqueue kernel! %d\n", err);
  return FALSE;
}
#endif
 
void init_global(dt_iop_module_so_t *self)
{
  const int program = 2; // basic.cl, from programs.conf
  dt_iop_flip_global_data_t *gd = (dt_iop_flip_global_data_t *)malloc(sizeof(dt_iop_flip_global_data_t));
  self->data = gd;
  gd->kernel_flip = dt_opencl_create_kernel(program, "flip");
}
 
void cleanup_global(dt_iop_module_so_t *self)
{
  const dt_iop_flip_global_data_t *gd = (dt_iop_flip_global_data_t *)self->data;
  dt_opencl_free_kernel(gd->kernel_flip);
  dt_free(self->data);
}
 
void commit_params(struct dt_iop_module_t *self, dt_iop_params_t *p1, dt_dev_pixelpipe_t *pipe,
                   dt_dev_pixelpipe_iop_t *piece)
{
  const dt_iop_flip_params_t *p = (dt_iop_flip_params_t *)p1;
  dt_iop_flip_data_t *d = (dt_iop_flip_data_t *)piece->data;
 
  d->orientation = _flip_resolve(self, p);
 
  if(d->orientation == ORIENTATION_NONE) piece->enabled = 0;
}
 
/* --- the geometry service's view of this module (develop/geometry/geometry.h) --------- */
 
typedef struct dt_iop_flip_geometry_t
{
  dt_image_orientation_t orientation;
} dt_iop_flip_geometry_t;
 
static void _flip_geometry_map_size(const void *data, const dt_iop_roi_t *const in, dt_iop_roi_t *out)
{
  _flip_map_size(((const dt_iop_flip_geometry_t *)data)->orientation, in, out);
}
 
static int _flip_geometry_transform(const void *data, const dt_geometry_record_t *const record,
                                    dt_geometry_chain_t *chain, float *points, size_t points_count)
{
  const dt_image_orientation_t orientation = ((const dt_iop_flip_geometry_t *)data)->orientation;
  for(size_t i = 0; i < points_count * 2; i += 2)
  {
    float x = points[i];
    float y = points[i + 1];
    if(orientation & ORIENTATION_FLIP_X) x = record->in.width - points[i];
    if(orientation & ORIENTATION_FLIP_Y) y = record->in.height - points[i + 1];
    if(orientation & ORIENTATION_SWAP_XY)
    {
      const float yy = y;
      y = x;
      x = yy;
    }
    points[i] = x;
    points[i + 1] = y;
  }
  return 1;
}
 
static int _flip_geometry_backtransform(const void *data, const dt_geometry_record_t *const record,
                                        dt_geometry_chain_t *chain, float *points, size_t points_count)
{
  const dt_image_orientation_t orientation = ((const dt_iop_flip_geometry_t *)data)->orientation;
  for(size_t i = 0; i < points_count * 2; i += 2)
  {
    float x = points[i];
    float y = points[i + 1];
    if(orientation & ORIENTATION_SWAP_XY)
    {
      const float yy = y;
      y = x;
      x = yy;
    }
    if(orientation & ORIENTATION_FLIP_X) x = record->in.width - x;
    if(orientation & ORIENTATION_FLIP_Y) y = record->in.height - y;
    points[i] = x;
    points[i + 1] = y;
  }
  return 1;
}
 
static const dt_geometry_vtable_t _flip_geometry_vtable = {
  .map_size = _flip_geometry_map_size,
  .transform = _flip_geometry_transform,
  .backtransform = _flip_geometry_backtransform,
};
 
gboolean geometry_record(dt_iop_module_t *self, const void *params, dt_geometry_record_t *record)
{
  const dt_image_orientation_t orientation
      = _flip_resolve(self, (const dt_iop_flip_params_t *)params);
 
  /* ORIENTATION_NONE is how commit_params() clears piece->enabled: an enabled flip module whose
   * resolved orientation is a no-op contributes nothing to the pipe, and must contribute nothing
   * here either. Published (so the roster is satisfied) with no vtable, which the chain reads as
   * identity -- the same thing a disabled piece is. */
  if(orientation == ORIENTATION_NONE) return TRUE;
 
  dt_iop_flip_geometry_t *data = (dt_iop_flip_geometry_t *)g_malloc0(sizeof(dt_iop_flip_geometry_t));
  if(IS_NULL_PTR(data)) return FALSE;
  data->orientation = orientation;
 
  record->data = data;
  record->free_data = dt_free_gpointer;
  record->vtable = &_flip_geometry_vtable;
  return TRUE;
}
 
void init_pipe(struct dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
  piece->data = dt_calloc_align(sizeof(dt_iop_flip_data_t));
  piece->data_size = sizeof(dt_iop_flip_data_t);
}
 
void cleanup_pipe(struct dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
  dt_free_align(piece->data);
  piece->data = NULL;
}
 
void init_presets(dt_iop_module_so_t *self)
{
  dt_iop_flip_params_t p = (dt_iop_flip_params_t){ ORIENTATION_NONE };
  dt_database_start_transaction();
 
  p.orientation = ORIENTATION_NULL;
  dt_gui_presets_add_generic(_("autodetect"), self->op,
                             self->version(), &p, sizeof(p), 1);
  dt_gui_presets_update_autoapply(_("autodetect"), self->op, self->version(), 1);
 
  p.orientation = ORIENTATION_NONE;
  dt_gui_presets_add_generic(_("no rotation"), self->op,
                             self->version(), &p, sizeof(p), 1);
 
  p.orientation = ORIENTATION_FLIP_HORIZONTALLY;
  dt_gui_presets_add_generic(_("flip horizontally"), self->op,
                             self->version(), &p, sizeof(p), 1);
 
  p.orientation = ORIENTATION_FLIP_VERTICALLY;
  dt_gui_presets_add_generic(_("flip vertically"), self->op,
                             self->version(), &p, sizeof(p), 1);
 
  p.orientation = ORIENTATION_ROTATE_CW_90_DEG;
  dt_gui_presets_add_generic(_("rotate by -90 degrees"), self->op,
                             self->version(), &p, sizeof(p), 1);
 
  p.orientation = ORIENTATION_ROTATE_CCW_90_DEG;
  dt_gui_presets_add_generic(_("rotate by  90 degrees"), self->op,
                             self->version(), &p, sizeof(p), 1);
 
  p.orientation = ORIENTATION_ROTATE_180_DEG;
  dt_gui_presets_add_generic(_("rotate by 180 degrees"), self->op,
                             self->version(), &p, sizeof(p), 1);
 
  dt_database_release_transaction();
}
 
void reload_defaults(dt_iop_module_t *self)
{
  dt_iop_flip_params_t *d = self->default_params;
 
  d->orientation = ORIENTATION_NULL;
 
  self->default_enabled = 1;
 
  if(self->dev->image_storage.legacy_flip.user_flip != 0
     && self->dev->image_storage.legacy_flip.user_flip != 0xff)
  {
    // The legacy flip bits only apply when the image has no flip history of its own.
    if(!dt_history_repository_module_exists(self->dev->image_storage.id, "flip"))
    {
      // convert the old legacy flip bits to a proper parameter set:
      d->orientation
          = merge_two_orientations(dt_image_orientation(&self->dev->image_storage),
                                   (dt_image_orientation_t)(self->dev->image_storage.legacy_flip.user_flip));
    }
  }
}
 
static void do_rotate(dt_iop_module_t *self, uint32_t cw)
{
  dt_iop_flip_params_t *p = (dt_iop_flip_params_t *)self->params;
  dt_image_orientation_t orientation = p->orientation;
 
  if(orientation == ORIENTATION_NULL) orientation = dt_image_orientation(&self->dev->image_storage);
 
  if(cw == 0)
  {
    if(orientation & ORIENTATION_SWAP_XY)
      orientation ^= ORIENTATION_FLIP_Y;
    else
      orientation ^= ORIENTATION_FLIP_X;
  }
  else
  {
    if(orientation & ORIENTATION_SWAP_XY)
      orientation ^= ORIENTATION_FLIP_X;
    else
      orientation ^= ORIENTATION_FLIP_Y;
  }
  orientation ^= ORIENTATION_SWAP_XY;
 
  p->orientation = orientation;
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
static void rotate_cw(GtkWidget *widget, dt_iop_module_t *self)
{
  do_rotate(self, 1);
}
static void rotate_ccw(GtkWidget *widget, dt_iop_module_t *self)
{
  do_rotate(self, 0);
}
static void _flip_h(GtkWidget *widget, dt_iop_module_t *self)
{
  dt_iop_flip_params_t *p = (dt_iop_flip_params_t *)self->params;
  dt_image_orientation_t orientation = p->orientation;
 
  if(orientation == ORIENTATION_NULL) orientation = dt_image_orientation(&self->dev->image_storage);
 
  if(orientation & ORIENTATION_SWAP_XY)
    p->orientation = orientation ^ ORIENTATION_FLIP_VERTICALLY;
  else
    p->orientation = orientation ^ ORIENTATION_FLIP_HORIZONTALLY;
 
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
static void _flip_v(GtkWidget *widget, dt_iop_module_t *self)
{
  dt_iop_flip_params_t *p = (dt_iop_flip_params_t *)self->params;
  dt_image_orientation_t orientation = p->orientation;
 
  if(orientation == ORIENTATION_NULL) orientation = dt_image_orientation(&self->dev->image_storage);
 
  if(orientation & ORIENTATION_SWAP_XY)
    p->orientation = orientation ^ ORIENTATION_FLIP_HORIZONTALLY;
  else
    p->orientation = orientation ^ ORIENTATION_FLIP_VERTICALLY;
 
  dt_dev_add_history_item(self->dev, self, TRUE, TRUE);
}
 
void gui_init(struct dt_iop_module_t *self)
{
  self->gui->gui_data = NULL;
  dt_iop_flip_params_t *p = (dt_iop_flip_params_t *)self->params;
 
  self->gui->widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_GUI_BOX_SPACING);
 
  GtkWidget *label = dt_iop_gui_reset_label_new(_("transform"), self, &p->orientation, sizeof(int32_t));
  gtk_box_pack_start(GTK_BOX(self->gui->widget), label, TRUE, TRUE, 0);
 
  dt_iop_button_new(self, N_("rotate 90 degrees CCW."),
                    G_CALLBACK(rotate_ccw), FALSE, GDK_KEY_bracketleft, 0,
                    dtgtk_cairo_paint_refresh, 0, self->gui->widget);
 
  dt_iop_button_new(self, N_("rotate 90 degrees CW."),
                    G_CALLBACK(rotate_cw), FALSE, GDK_KEY_bracketright, 0,
                    dtgtk_cairo_paint_refresh, 1, self->gui->widget);
 
  dt_iop_button_new(self, N_("flip horizontally."), G_CALLBACK(_flip_h), FALSE, 0, 0, dtgtk_cairo_paint_flip, 1,
                    self->gui->widget);
 
  dt_iop_button_new(self, N_("flip vertically."), G_CALLBACK(_flip_v), FALSE, 0, 0, dtgtk_cairo_paint_flip, 0,
                    self->gui->widget);
}
 
void gui_cleanup(struct dt_iop_module_t *self)
{
  self->gui->gui_data = NULL;
}
 
// 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