Adding upstream version 2.10.36.upstream/2.10.36

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 827 insertions, 0 deletions

diff --git a/app/gegl/gimp-gegl-apply-operation.c b/app/gegl/gimp-gegl-apply-operation.c
new file mode 100644
index 0000000..d76b3b1
--- /dev/null
+++ b/app/gegl/gimp-gegl-apply-operation.c
@@ -0,0 +1,827 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimp-apply-operation.c
+ * Copyright (C) 2012 Øyvind Kolås <pippin@gimp.org>
+ *                    Sven Neumann <sven@gimp.org>
+ *                    Michael Natterer <mitch@gimp.org>
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <cairo.h>
+#include <gio/gio.h>
+#include <gegl.h>
+
+#include "gimp-gegl-types.h"
+
+#include "core/gimp-transform-utils.h"
+#include "core/gimp-utils.h"
+#include "core/gimpchunkiterator.h"
+#include "core/gimpprogress.h"
+
+#include "gimp-gegl-apply-operation.h"
+#include "gimp-gegl-loops.h"
+#include "gimp-gegl-nodes.h"
+#include "gimp-gegl-utils.h"
+
+
+/* iteration interval when applying an operation interactively
+ * (with progress indication)
+ */
+#define APPLY_OPERATION_INTERACTIVE_INTERVAL    (1.0 / 8.0) /* seconds */
+
+/* iteration interval when applying an operation non-interactively
+ * (without progress indication)
+ */
+#define APPLY_OPERATION_NON_INTERACTIVE_INTERVAL 1.0 /* seconds */
+
+
+void
+gimp_gegl_apply_operation (GeglBuffer          *src_buffer,
+                           GimpProgress        *progress,
+                           const gchar         *undo_desc,
+                           GeglNode            *operation,
+                           GeglBuffer          *dest_buffer,
+                           const GeglRectangle *dest_rect,
+                           gboolean             crop_input)
+{
+  gimp_gegl_apply_cached_operation (src_buffer,
+                                    progress, undo_desc,
+                                    operation,
+                                    src_buffer != NULL,
+                                    dest_buffer,
+                                    dest_rect,
+                                    crop_input,
+                                    NULL, NULL, 0,
+                                    FALSE);
+}
+
+static void
+gimp_gegl_apply_operation_cancel (GimpProgress *progress,
+                                  gboolean     *cancel)
+{
+  *cancel = TRUE;
+}
+
+gboolean
+gimp_gegl_apply_cached_operation (GeglBuffer          *src_buffer,
+                                  GimpProgress        *progress,
+                                  const gchar         *undo_desc,
+                                  GeglNode            *operation,
+                                  gboolean             connect_src_buffer,
+                                  GeglBuffer          *dest_buffer,
+                                  const GeglRectangle *dest_rect,
+                                  gboolean             crop_input,
+                                  GeglBuffer          *cache,
+                                  const GeglRectangle *valid_rects,
+                                  gint                 n_valid_rects,
+                                  gboolean             cancelable)
+{
+  GeglNode          *gegl;
+  GeglNode          *effect;
+  GeglNode          *dest_node;
+  GeglNode          *underlying_operation;
+  GeglNode          *operation_src_node = NULL;
+  GeglBuffer        *result_buffer;
+  GimpChunkIterator *iter;
+  cairo_region_t    *region;
+  gboolean           progress_started   = FALSE;
+  gboolean           cancel             = FALSE;
+  gint64             all_pixels;
+  gint64             done_pixels;
+
+  g_return_val_if_fail (src_buffer == NULL || GEGL_IS_BUFFER (src_buffer), FALSE);
+  g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE);
+  g_return_val_if_fail (GEGL_IS_NODE (operation), FALSE);
+  g_return_val_if_fail (GEGL_IS_BUFFER (dest_buffer), FALSE);
+  g_return_val_if_fail (cache == NULL || GEGL_IS_BUFFER (cache), FALSE);
+  g_return_val_if_fail (valid_rects == NULL || cache != NULL, FALSE);
+  g_return_val_if_fail (valid_rects == NULL || n_valid_rects != 0, FALSE);
+
+  if (! dest_rect)
+    dest_rect = gegl_buffer_get_extent (dest_buffer);
+
+  if (progress)
+    {
+      if (gimp_progress_is_active (progress))
+        {
+          if (undo_desc)
+            gimp_progress_set_text_literal (progress, undo_desc);
+
+          progress_started = FALSE;
+          cancelable       = FALSE;
+        }
+      else
+        {
+          gimp_progress_start (progress, cancelable, "%s", undo_desc);
+
+          if (cancelable)
+            g_signal_connect (progress, "cancel",
+                              G_CALLBACK (gimp_gegl_apply_operation_cancel),
+                              &cancel);
+
+          progress_started = TRUE;
+        }
+    }
+  else
+    {
+      cancelable = FALSE;
+    }
+
+  gegl_buffer_freeze_changed (dest_buffer);
+
+  underlying_operation = gimp_gegl_node_get_underlying_operation (operation);
+
+  result_buffer = dest_buffer;
+
+  if (result_buffer == src_buffer &&
+      ! (gimp_gegl_node_is_point_operation  (underlying_operation) ||
+         gimp_gegl_node_is_source_operation (underlying_operation)))
+    {
+      /* Write the result to a temporary buffer, instead of directly to
+       * dest_buffer, since reading and writing the same buffer doesn't
+       * generally work with non-point ops when working in chunks.
+       *
+       * See bug #701875.
+       */
+
+      if (cache)
+        {
+          /* If we have a cache, use it directly as the temporary result
+           * buffer, and skip copying the cached results to result_buffer
+           * below.  Instead, the cached results are copied together with the
+           * newly rendered results in a single step at the end of processing.
+           */
+
+          g_warn_if_fail (cache != dest_buffer);
+
+          result_buffer = g_object_ref (cache);
+
+          cache = NULL;
+        }
+      else
+        {
+          result_buffer = gegl_buffer_new (
+            dest_rect, gegl_buffer_get_format (dest_buffer));
+        }
+    }
+
+  all_pixels  = (gint64) dest_rect->width * (gint64) dest_rect->height;
+  done_pixels = 0;
+
+  region = cairo_region_create_rectangle ((cairo_rectangle_int_t *) dest_rect);
+
+  if (n_valid_rects > 0)
+    {
+      gint i;
+
+      for (i = 0; i < n_valid_rects; i++)
+        {
+          GeglRectangle valid_rect;
+
+          if (! gegl_rectangle_intersect (&valid_rect,
+                                          &valid_rects[i], dest_rect))
+            {
+              continue;
+            }
+
+          if (cache)
+            {
+              gimp_gegl_buffer_copy (
+                cache,         &valid_rect, GEGL_ABYSS_NONE,
+                result_buffer, &valid_rect);
+            }
+
+          cairo_region_subtract_rectangle (region,
+                                           (cairo_rectangle_int_t *)
+                                           &valid_rect);
+
+          done_pixels += (gint64) valid_rect.width * (gint64) valid_rect.height;
+
+          if (progress)
+            {
+              gimp_progress_set_value (progress,
+                                       (gdouble) done_pixels /
+                                       (gdouble) all_pixels);
+            }
+        }
+    }
+
+  gegl = gegl_node_new ();
+
+  if (! gegl_node_get_parent (operation))
+    gegl_node_add_child (gegl, operation);
+
+  effect = operation;
+
+  if (connect_src_buffer || crop_input)
+    {
+      GeglNode *src_node;
+
+      operation_src_node = gegl_node_get_producer (operation, "input", NULL);
+
+      src_node = operation_src_node;
+
+      if (connect_src_buffer)
+        {
+          src_node = gegl_node_new_child (gegl,
+                                          "operation", "gegl:buffer-source",
+                                          "buffer",    src_buffer,
+                                          NULL);
+        }
+
+      if (crop_input)
+        {
+          GeglNode *crop_node;
+
+          crop_node = gegl_node_new_child (gegl,
+                                           "operation", "gegl:crop",
+                                           "x",         (gdouble) dest_rect->x,
+                                           "y",         (gdouble) dest_rect->y,
+                                           "width",     (gdouble) dest_rect->width,
+                                           "height",    (gdouble) dest_rect->height,
+                                           NULL);
+
+          gegl_node_connect_to (src_node,  "output",
+                                crop_node, "input");
+
+          src_node = crop_node;
+        }
+
+      if (! gegl_node_has_pad (operation, "input"))
+        {
+          effect = gegl_node_new_child (gegl,
+                                        "operation", "gimp:normal",
+                                        NULL);
+
+          gegl_node_connect_to (operation, "output",
+                                effect,    "aux");
+        }
+
+      gegl_node_connect_to (src_node, "output",
+                            effect,   "input");
+    }
+
+  dest_node = gegl_node_new_child (gegl,
+                                   "operation", "gegl:write-buffer",
+                                   "buffer",    result_buffer,
+                                   NULL);
+
+  gegl_node_connect_to (effect,    "output",
+                        dest_node, "input");
+
+  iter = gimp_chunk_iterator_new (region);
+
+  if (progress &&
+      /* avoid the interactive iteration interval for area filters (or meta ops
+       * that potentially involve area filters), since their processing speed
+       * tends to be sensitive to the chunk size.
+       */
+      ! gimp_gegl_node_is_area_filter_operation (underlying_operation))
+    {
+      /* we use a shorter iteration interval for interactive use (when there's
+       * progress indication), to stay responsive.
+       */
+      gimp_chunk_iterator_set_interval (
+        iter,
+        APPLY_OPERATION_INTERACTIVE_INTERVAL);
+    }
+  else
+    {
+      /* we use a longer iteration interval for non-interactive use (when
+       * there's no progress indication), or when applying an area filter (see
+       * above), as this generally allows for faster processing.  we don't
+       * avoid chunking altogether, since *some* chunking is still desirable to
+       * reduce the space needed for intermediate results.
+       */
+      gimp_chunk_iterator_set_interval (
+        iter,
+        APPLY_OPERATION_NON_INTERACTIVE_INTERVAL);
+    }
+
+  while (gimp_chunk_iterator_next (iter))
+    {
+      GeglRectangle render_rect;
+
+      if (cancelable)
+        {
+          while (! cancel && g_main_context_pending (NULL))
+            g_main_context_iteration (NULL, FALSE);
+
+          if (cancel)
+            break;
+        }
+
+      while (gimp_chunk_iterator_get_rect (iter, &render_rect))
+        {
+          gegl_node_blit (dest_node, 1.0, &render_rect, NULL, NULL, 0,
+                          GEGL_BLIT_DEFAULT);
+
+          done_pixels += (gint64) render_rect.width *
+                         (gint64) render_rect.height;
+        }
+
+      if (progress)
+        {
+          gimp_progress_set_value (progress,
+                                   (gdouble) done_pixels /
+                                   (gdouble) all_pixels);
+        }
+    }
+
+  if (result_buffer != dest_buffer)
+    {
+      if (! cancel)
+        gimp_gegl_buffer_copy (result_buffer, dest_rect, GEGL_ABYSS_NONE,
+                               dest_buffer,   dest_rect);
+
+      g_object_unref (result_buffer);
+    }
+
+  gegl_buffer_thaw_changed (dest_buffer);
+
+  g_object_unref (gegl);
+
+  if (operation_src_node)
+    {
+      gegl_node_connect_to (operation_src_node, "output",
+                            operation,          "input");
+    }
+
+  if (progress_started)
+    {
+      gimp_progress_end (progress);
+
+      if (cancelable)
+        g_signal_handlers_disconnect_by_func (progress,
+                                              gimp_gegl_apply_operation_cancel,
+                                              &cancel);
+    }
+
+  return ! cancel;
+}
+
+void
+gimp_gegl_apply_dither (GeglBuffer   *src_buffer,
+                        GimpProgress *progress,
+                        const gchar  *undo_desc,
+                        GeglBuffer   *dest_buffer,
+                        gint          levels,
+                        gint          dither_type)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  levels = CLAMP (levels, 2, 65536);
+
+  node = gegl_node_new_child (NULL,
+                              "operation",     "gegl:dither",
+                              "red-levels",    levels,
+                              "green-levels",  levels,
+                              "blue-levels",   levels,
+                              "alpha-bits",    levels,
+                              "dither-method", dither_type,
+                              NULL);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, NULL, FALSE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_flatten (GeglBuffer          *src_buffer,
+                         GimpProgress        *progress,
+                         const gchar         *undo_desc,
+                         GeglBuffer          *dest_buffer,
+                         const GimpRGB       *background,
+                         GimpLayerColorSpace  composite_space)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+  g_return_if_fail (background != NULL);
+
+  node = gimp_gegl_create_flatten_node (background, composite_space);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, NULL, FALSE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_feather (GeglBuffer          *src_buffer,
+                         GimpProgress        *progress,
+                         const gchar         *undo_desc,
+                         GeglBuffer          *dest_buffer,
+                         const GeglRectangle *dest_rect,
+                         gdouble              radius_x,
+                         gdouble              radius_y,
+                         gboolean             edge_lock)
+{
+  GaussianBlurAbyssPolicy abyss_policy;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  if (edge_lock)
+    abyss_policy = GAUSSIAN_BLUR_ABYSS_CLAMP;
+  else
+    abyss_policy = GAUSSIAN_BLUR_ABYSS_NONE;
+
+  /* 3.5 is completely magic and picked to visually match the old
+   * gaussian_blur_region() on a crappy laptop display
+   */
+  gimp_gegl_apply_gaussian_blur (src_buffer,
+                                 progress, undo_desc,
+                                 dest_buffer, dest_rect,
+                                 radius_x / 3.5,
+                                 radius_y / 3.5,
+                                 abyss_policy);
+}
+
+void
+gimp_gegl_apply_border (GeglBuffer             *src_buffer,
+                        GimpProgress           *progress,
+                        const gchar            *undo_desc,
+                        GeglBuffer             *dest_buffer,
+                        const GeglRectangle    *dest_rect,
+                        gint                    radius_x,
+                        gint                    radius_y,
+                        GimpChannelBorderStyle  style,
+                        gboolean                edge_lock)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  switch (style)
+    {
+    case GIMP_CHANNEL_BORDER_STYLE_HARD:
+    case GIMP_CHANNEL_BORDER_STYLE_FEATHERED:
+      {
+        gboolean feather = style == GIMP_CHANNEL_BORDER_STYLE_FEATHERED;
+
+        node = gegl_node_new_child (NULL,
+                                    "operation", "gimp:border",
+                                    "radius-x",  radius_x,
+                                    "radius-y",  radius_y,
+                                    "feather",   feather,
+                                    "edge-lock", edge_lock,
+                                    NULL);
+      }
+      break;
+
+    case GIMP_CHANNEL_BORDER_STYLE_SMOOTH:
+      {
+        GeglNode *input, *output;
+        GeglNode *grow, *shrink, *subtract;
+
+        node   = gegl_node_new ();
+
+        input  = gegl_node_get_input_proxy (node, "input");
+        output = gegl_node_get_output_proxy (node, "output");
+
+        /* Duplicate special-case behavior of "gimp:border". */
+        if (radius_x == 1 && radius_y == 1)
+          {
+            grow   = gegl_node_new_child (node,
+                                          "operation", "gegl:nop",
+                                          NULL);
+            shrink = gegl_node_new_child (node,
+                                          "operation", "gimp:shrink",
+                                          "radius-x",  1,
+                                          "radius-y",  1,
+                                          "edge-lock", edge_lock,
+                                          NULL);
+          }
+        else
+          {
+            grow   = gegl_node_new_child (node,
+                                          "operation", "gimp:grow",
+                                          "radius-x",  radius_x,
+                                          "radius-y",  radius_y,
+                                          NULL);
+            shrink = gegl_node_new_child (node,
+                                          "operation", "gimp:shrink",
+                                          "radius-x",  radius_x + 1,
+                                          "radius-y",  radius_y + 1,
+                                          "edge-lock", edge_lock,
+                                          NULL);
+          }
+
+        subtract = gegl_node_new_child (node,
+                                        "operation", "gegl:subtract",
+                                        NULL);
+
+        gegl_node_link_many (input, grow, subtract, output, NULL);
+        gegl_node_link (input, shrink);
+        gegl_node_connect_to (shrink, "output", subtract, "aux");
+      }
+      break;
+
+    default:
+      gimp_assert_not_reached ();
+    }
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, dest_rect, TRUE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_grow (GeglBuffer          *src_buffer,
+                      GimpProgress        *progress,
+                      const gchar         *undo_desc,
+                      GeglBuffer          *dest_buffer,
+                      const GeglRectangle *dest_rect,
+                      gint                 radius_x,
+                      gint                 radius_y)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  node = gegl_node_new_child (NULL,
+                              "operation", "gimp:grow",
+                              "radius-x",  radius_x,
+                              "radius-y",  radius_y,
+                              NULL);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, dest_rect, TRUE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_shrink (GeglBuffer          *src_buffer,
+                        GimpProgress        *progress,
+                        const gchar         *undo_desc,
+                        GeglBuffer          *dest_buffer,
+                        const GeglRectangle *dest_rect,
+                        gint                 radius_x,
+                        gint                 radius_y,
+                        gboolean             edge_lock)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  node = gegl_node_new_child (NULL,
+                              "operation", "gimp:shrink",
+                              "radius-x",  radius_x,
+                              "radius-y",  radius_y,
+                              "edge-lock", edge_lock,
+                              NULL);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, dest_rect, TRUE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_flood (GeglBuffer          *src_buffer,
+                       GimpProgress        *progress,
+                       const gchar         *undo_desc,
+                       GeglBuffer          *dest_buffer,
+                       const GeglRectangle *dest_rect)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  node = gegl_node_new_child (NULL,
+                              "operation", "gimp:flood",
+                              NULL);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, dest_rect, TRUE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_gaussian_blur (GeglBuffer              *src_buffer,
+                               GimpProgress            *progress,
+                               const gchar             *undo_desc,
+                               GeglBuffer              *dest_buffer,
+                               const GeglRectangle     *dest_rect,
+                               gdouble                  std_dev_x,
+                               gdouble                  std_dev_y,
+                               GaussianBlurAbyssPolicy  abyss_policy)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  node = gegl_node_new_child (NULL,
+                              "operation",    "gegl:gaussian-blur",
+                              "std-dev-x",    std_dev_x,
+                              "std-dev-y",    std_dev_y,
+                              "abyss-policy", abyss_policy,
+                              NULL);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, dest_rect, FALSE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_invert_gamma (GeglBuffer    *src_buffer,
+                              GimpProgress  *progress,
+                              const gchar   *undo_desc,
+                              GeglBuffer    *dest_buffer)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  node = gegl_node_new_child (NULL,
+                              "operation", "gegl:invert-gamma",
+                              NULL);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, NULL, FALSE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_invert_linear (GeglBuffer    *src_buffer,
+                               GimpProgress  *progress,
+                               const gchar   *undo_desc,
+                               GeglBuffer    *dest_buffer)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  node = gegl_node_new_child (NULL,
+                              "operation", "gegl:invert-linear",
+                              NULL);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, NULL, FALSE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_opacity (GeglBuffer    *src_buffer,
+                         GimpProgress  *progress,
+                         const gchar   *undo_desc,
+                         GeglBuffer    *dest_buffer,
+                         GeglBuffer    *mask,
+                         gint           mask_offset_x,
+                         gint           mask_offset_y,
+                         gdouble        opacity)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+  g_return_if_fail (mask == NULL || GEGL_IS_BUFFER (mask));
+
+  node = gimp_gegl_create_apply_opacity_node (mask,
+                                              mask_offset_x,
+                                              mask_offset_y,
+                                              opacity);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, NULL, FALSE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_scale (GeglBuffer            *src_buffer,
+                       GimpProgress          *progress,
+                       const gchar           *undo_desc,
+                       GeglBuffer            *dest_buffer,
+                       GimpInterpolationType  interpolation_type,
+                       gdouble                x,
+                       gdouble                y)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  node = gegl_node_new_child (NULL,
+                              "operation",   "gegl:scale-ratio",
+                              "origin-x",     0.0,
+                              "origin-y",     0.0,
+                              "sampler",      interpolation_type,
+                              "abyss-policy", GEGL_ABYSS_CLAMP,
+                              "x",            x,
+                              "y",            y,
+                              NULL);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, NULL, FALSE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_set_alpha (GeglBuffer    *src_buffer,
+                           GimpProgress  *progress,
+                           const gchar   *undo_desc,
+                           GeglBuffer    *dest_buffer,
+                           gdouble        value)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  node = gegl_node_new_child (NULL,
+                              "operation", "gimp:set-alpha",
+                              "value",     value,
+                              NULL);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, NULL, FALSE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_threshold (GeglBuffer    *src_buffer,
+                           GimpProgress  *progress,
+                           const gchar   *undo_desc,
+                           GeglBuffer    *dest_buffer,
+                           gdouble        value)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  node = gegl_node_new_child (NULL,
+                              "operation", "gegl:threshold",
+                              "value",     value,
+                              NULL);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, NULL, FALSE);
+  g_object_unref (node);
+}
+
+void
+gimp_gegl_apply_transform (GeglBuffer            *src_buffer,
+                           GimpProgress          *progress,
+                           const gchar           *undo_desc,
+                           GeglBuffer            *dest_buffer,
+                           GimpInterpolationType  interpolation_type,
+                           GimpMatrix3           *transform)
+{
+  GeglNode *node;
+
+  g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
+  g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress));
+  g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
+
+  node = gegl_node_new_child (NULL,
+                              "operation", "gegl:transform",
+                              "near-z",    GIMP_TRANSFORM_NEAR_Z,
+                              "sampler",   interpolation_type,
+                              NULL);
+
+  gimp_gegl_node_set_matrix (node, transform);
+
+  gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
+                             node, dest_buffer, NULL, FALSE);
+  g_object_unref (node);
+}