dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
gimp/app/gegl/gimp-gegl-apply-operation.c

747 lines
26 KiB
C
Raw Normal View History

app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
/* 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
Change the license URL from http://www.gnu.org/licenses/ to https://
2018-07-12 05:27:07 +08:00
* along with this program. If not, see <https://www.gnu.org/licenses/>.
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
*/
#include "config.h"
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
#include <cairo.h>
app: move gimp_file_compare() to gimp-utils.[ch] It's a GCompareFunc to be used for finding GFiles in lists.
2014-08-02 21:07:26 +08:00
#include <gio/gio.h>
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
#include <gegl.h>
app: move core/gimp-apply-operation.[ch] to gegl/gimp-gegl-apply-operation.[ch]
2012-10-22 22:03:40 +08:00
#include "gimp-gegl-types.h"
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
app: pass near-plane z-coordinate to gegl:transform ... so that GEGL performs the same clipping we do.
2018-01-29 04:53:01 +08:00
#include "core/gimp-transform-utils.h"
app: move core/gimp-apply-operation.[ch] to gegl/gimp-gegl-apply-operation.[ch]
2012-10-22 22:03:40 +08:00
#include "core/gimp-utils.h"
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
#include "core/gimpchunkiterator.h"
app: move core/gimp-apply-operation.[ch] to gegl/gimp-gegl-apply-operation.[ch]
2012-10-22 22:03:40 +08:00
#include "core/gimpprogress.h"
#include "gimp-gegl-apply-operation.h"
app: use gimp_gegl_buffer_copy() all over the place Replace all uses of gegl_buffer_copy() in app/ with gimp_gegl_buffer_copy(), added in the previous commit.
2018-05-24 22:21:21 +08:00
#include "gimp-gegl-loops.h"
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
#include "gimp-gegl-nodes.h"
app: use gimp_gegl_buffer_copy() all over the place Replace all uses of gegl_buffer_copy() in app/ with gimp_gegl_buffer_copy(), added in the previous commit.
2018-05-24 22:21:21 +08:00
#include "gimp-gegl-utils.h"
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
void
app: move core/gimp-apply-operation.[ch] to gegl/gimp-gegl-apply-operation.[ch]
2012-10-22 22:03:40 +08:00
gimp_gegl_apply_operation (GeglBuffer *src_buffer,
GimpProgress *progress,
const gchar *undo_desc,
GeglNode *operation,
GeglBuffer *dest_buffer,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
const GeglRectangle *dest_rect,
gboolean crop_input)
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
{
gimp_gegl_apply_cached_operation (src_buffer,
progress, undo_desc,
operation,
dest_buffer,
dest_rect,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
crop_input,
app: make gimp_gegl_apply_cached_operation() cancelable via GimpProgress In gimp_drawable_merge_filter(), use that feature to make filter applying cancelable. Stop projection rendering first, because we have to run the event loop manually in order to receive input for canceling, but we don't want the projection to be constructed from that manual loop running.
2014-06-30 06:10:25 +08:00
NULL, NULL, 0,
FALSE);
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
}
app: make gimp_gegl_apply_cached_operation() cancelable via GimpProgress In gimp_drawable_merge_filter(), use that feature to make filter applying cancelable. Stop projection rendering first, because we have to run the event loop manually in order to receive input for canceling, but we don't want the projection to be constructed from that manual loop running.
2014-06-30 06:10:25 +08:00
static void
gimp_gegl_apply_operation_cancel (GimpProgress *progress,
gboolean *cancel)
{
*cancel = TRUE;
}
gboolean
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
gimp_gegl_apply_cached_operation (GeglBuffer *src_buffer,
GimpProgress *progress,
const gchar *undo_desc,
GeglNode *operation,
GeglBuffer *dest_buffer,
const GeglRectangle *dest_rect,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
gboolean crop_input,
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
GeglBuffer *cache,
const GeglRectangle *valid_rects,
app: make gimp_gegl_apply_cached_operation() cancelable via GimpProgress In gimp_drawable_merge_filter(), use that feature to make filter applying cancelable. Stop projection rendering first, because we have to run the event loop manually in order to receive input for canceling, but we don't want the projection to be constructed from that manual loop running.
2014-06-30 06:10:25 +08:00
gint n_valid_rects,
app: remove all calls to gdk_window_process_updated() - remove gimp_widget_flush_expose() - remove the "now" argument to gimp_display_shell_flush() and make it only update widget states - rename gimp_display_flush_whenever() to gimp_display_flush_update_region() and call gimp_display_shell_flush() separately in the only case we passed FALSE to flush_whenever() - remove th flush_now interval logic from GimpDisplay, as soon as we have exposed the canvas, we are in the loop for the next frame clock tick anyway, so delaying a useless and removed process_updates serves no purpose - in gimptool-progress.c, create the invisible grab widget also for non-cencelable cases, so we can always safely run the main loop manually to make the progress updates visible - in gimp-gegl-apply-operation.c, always run the main loop manually to make the progress updates visible - in gimpstatusbar.c, leave some FIXME comments as reminder that we might need the same logic as in gimptool-progress.c
2018-07-01 22:19:54 +08:00
gboolean cancelable)
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
{
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
GeglNode *gegl;
GeglNode *effect;
GeglNode *dest_node;
GeglNode *operation_src_node = NULL;
GimpChunkIterator *iter;
cairo_region_t *region;
GeglRectangle rect = { 0, };
gboolean progress_started = FALSE;
gboolean cancel = FALSE;
gint all_pixels;
gint done_pixels;
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
app: Always return values in non-void functions.
2014-06-30 10:35:34 +08:00
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);
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
if (dest_rect)
{
rect = *dest_rect;
}
else
{
app: s/GIMP_GEGL_RECT/GEGL_RECTANGLE/ Defining GeglRectangle inline is so useful that it has been added to GEGL.
2012-04-02 21:19:47 +08:00
rect = *GEGL_RECTANGLE (0, 0, gegl_buffer_get_width (dest_buffer),
app: make use of GIMP_GEGL_RECT in more places
2012-03-21 10:57:53 +08:00
gegl_buffer_get_height (dest_buffer));
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
}
gegl = gegl_node_new ();
app: allow a NULL src_buffer in gimp_gegl_apply_operation() in which case the function just does nothing on the passed operation's input and expects it to be already conntected to something. Also allow to pass an operation that is already part of another graph.
2013-04-22 16:55:09 +08:00
if (! gegl_node_get_parent (operation))
gegl_node_add_child (gegl, operation);
app: fix gimp_gegl_apply_operation() for source OPs Blend them on top of the source buffer using gegl:over like GimpDrawableFilter does interactively. Fixes "Repeat Last" and probably some other stuff for source OPs.
2018-05-07 20:26:26 +08:00
effect = operation;
if (src_buffer)
app: allow a NULL src_buffer in gimp_gegl_apply_operation() in which case the function just does nothing on the passed operation's input and expects it to be already conntected to something. Also allow to pass an operation that is already part of another graph.
2013-04-22 16:55:09 +08:00
{
GeglNode *src_node;
app: don't run graphs that read and write the same buffer Work around artifacts at processing chunk borders by dup()ing the source buffer. See bug #701875.
2013-06-18 14:06:24 +08:00
/* dup() because reading and writing the same buffer doesn't
app: in gimp_gegl_apply_cached_operation(), don't dup src buffer for point ops In gimp_gegl_apply_cached_operation(), when the source and destination buffers are the same, avoid duplicating the source buffer when the applied operation is a point operation, since applying it in chunks from/to the same buffer is not a problem in this case.
2019-02-16 01:28:30 +08:00
* generally work with non-point ops when working in chunks.
* See bug #701875.
app: don't run graphs that read and write the same buffer Work around artifacts at processing chunk borders by dup()ing the source buffer. See bug #701875.
2013-06-18 14:06:24 +08:00
*/
app: in gimp_gegl_apply_cached_operation(), don't dup src buffer for point ops In gimp_gegl_apply_cached_operation(), when the source and destination buffers are the same, avoid duplicating the source buffer when the applied operation is a point operation, since applying it in chunks from/to the same buffer is not a problem in this case.
2019-02-16 01:28:30 +08:00
if (src_buffer == dest_buffer &&
! gimp_gegl_node_is_point_operation (operation))
{
src_buffer = gegl_buffer_dup (src_buffer);
}
app: don't run graphs that read and write the same buffer Work around artifacts at processing chunk borders by dup()ing the source buffer. See bug #701875.
2013-06-18 14:06:24 +08:00
else
app: in gimp_gegl_apply_cached_operation(), don't dup src buffer for point ops In gimp_gegl_apply_cached_operation(), when the source and destination buffers are the same, avoid duplicating the source buffer when the applied operation is a point operation, since applying it in chunks from/to the same buffer is not a problem in this case.
2019-02-16 01:28:30 +08:00
{
g_object_ref (src_buffer);
}
app: don't run graphs that read and write the same buffer Work around artifacts at processing chunk borders by dup()ing the source buffer. See bug #701875.
2013-06-18 14:06:24 +08:00
app: allow a NULL src_buffer in gimp_gegl_apply_operation() in which case the function just does nothing on the passed operation's input and expects it to be already conntected to something. Also allow to pass an operation that is already part of another graph.
2013-04-22 16:55:09 +08:00
src_node = gegl_node_new_child (gegl,
"operation", "gegl:buffer-source",
"buffer", src_buffer,
NULL);
app: don't run graphs that read and write the same buffer Work around artifacts at processing chunk borders by dup()ing the source buffer. See bug #701875.
2013-06-18 14:06:24 +08:00
g_object_unref (src_buffer);
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
if (crop_input)
{
GeglNode *crop_node;
crop_node = gegl_node_new_child (gegl,
"operation", "gegl:crop",
"x", (gdouble) rect.x,
"y", (gdouble) rect.y,
"width", (gdouble) rect.width,
"height", (gdouble) rect.height,
NULL);
gegl_node_connect_to (src_node, "output",
crop_node, "input");
src_node = crop_node;
}
app: restore operation src node in gimp_gegl_apply_[cached_]operation() When merging a drawable filter, we call gimp_gegl_apply_cached_operation() on a node that's part of the drawable's filter stack graph. The function rewires the node's input, and doesn't restore its original input connection before returning, leaving the graph in an inconsistent state. Currently, this doesn't matter, since we remove the filter right after that, but the next commit expects the filter stack graph to remain consistent. Remember the original source node of "operation" in gimp_gegl_apply_cached_operation(), and restore it upon exit, to fix that.
2017-12-06 02:34:43 +08:00
operation_src_node = gegl_node_get_producer (operation, "input", NULL);
app: fix gimp_gegl_apply_operation() for source OPs Blend them on top of the source buffer using gegl:over like GimpDrawableFilter does interactively. Fixes "Repeat Last" and probably some other stuff for source OPs.
2018-05-07 20:26:26 +08:00
if (! gegl_node_has_pad (operation, "input"))
{
effect = gegl_node_new_child (gegl,
app: use gimp:normal instead of gegl:over in gimp_gegl_apply_cached_operation() When the operation doesn't have an input pad, composite it over the input using gimp:normal, instead of gegl:over, for consistency with the rest of our compositing code (although the result should be the same).
2018-05-08 02:36:29 +08:00
"operation", "gimp:normal",
app: fix gimp_gegl_apply_operation() for source OPs Blend them on top of the source buffer using gegl:over like GimpDrawableFilter does interactively. Fixes "Repeat Last" and probably some other stuff for source OPs.
2018-05-07 20:26:26 +08:00
NULL);
gegl_node_connect_to (operation, "output",
effect, "aux");
}
gegl_node_connect_to (src_node, "output",
effect, "input");
app: allow a NULL src_buffer in gimp_gegl_apply_operation() in which case the function just does nothing on the passed operation's input and expects it to be already conntected to something. Also allow to pass an operation that is already part of another graph.
2013-04-22 16:55:09 +08:00
}
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
dest_node = gegl_node_new_child (gegl,
"operation", "gegl:write-buffer",
"buffer", dest_buffer,
NULL);
app: fix gimp_gegl_apply_operation() for source OPs Blend them on top of the source buffer using gegl:over like GimpDrawableFilter does interactively. Fixes "Repeat Last" and probably some other stuff for source OPs.
2018-05-07 20:26:26 +08:00
gegl_node_connect_to (effect, "output",
app: allow a NULL src_buffer in gimp_gegl_apply_operation() in which case the function just does nothing on the passed operation's input and expects it to be already conntected to something. Also allow to pass an operation that is already part of another graph.
2013-04-22 16:55:09 +08:00
dest_node, "input");
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
if (progress)
app: be smarter about progress in gimp_apply_operation() so an already started progress can be passed in.
2012-03-20 06:57:50 +08:00
{
app: make gimp_gegl_apply_cached_operation() cancelable via GimpProgress In gimp_drawable_merge_filter(), use that feature to make filter applying cancelable. Stop projection rendering first, because we have to run the event loop manually in order to receive input for canceling, but we don't want the projection to be constructed from that manual loop running.
2014-06-30 06:10:25 +08:00
if (gimp_progress_is_active (progress))
app: be smarter about progress in gimp_apply_operation() so an already started progress can be passed in.
2012-03-20 06:57:50 +08:00
{
if (undo_desc)
app: add gimp_progress_set_text_literal() and use it instead of set_text (progress, "%s", literal_message);
2014-07-21 05:32:19 +08:00
gimp_progress_set_text_literal (progress, undo_desc);
app: make gimp_gegl_apply_cached_operation() cancelable via GimpProgress In gimp_drawable_merge_filter(), use that feature to make filter applying cancelable. Stop projection rendering first, because we have to run the event loop manually in order to receive input for canceling, but we don't want the projection to be constructed from that manual loop running.
2014-06-30 06:10:25 +08:00
progress_started = FALSE;
app: remove all calls to gdk_window_process_updated() - remove gimp_widget_flush_expose() - remove the "now" argument to gimp_display_shell_flush() and make it only update widget states - rename gimp_display_flush_whenever() to gimp_display_flush_update_region() and call gimp_display_shell_flush() separately in the only case we passed FALSE to flush_whenever() - remove th flush_now interval logic from GimpDisplay, as soon as we have exposed the canvas, we are in the loop for the next frame clock tick anyway, so delaying a useless and removed process_updates serves no purpose - in gimptool-progress.c, create the invisible grab widget also for non-cencelable cases, so we can always safely run the main loop manually to make the progress updates visible - in gimp-gegl-apply-operation.c, always run the main loop manually to make the progress updates visible - in gimpstatusbar.c, leave some FIXME comments as reminder that we might need the same logic as in gimptool-progress.c
2018-07-01 22:19:54 +08:00
cancelable = FALSE;
app: be smarter about progress in gimp_apply_operation() so an already started progress can be passed in.
2012-03-20 06:57:50 +08:00
}
else
{
app: remove all calls to gdk_window_process_updated() - remove gimp_widget_flush_expose() - remove the "now" argument to gimp_display_shell_flush() and make it only update widget states - rename gimp_display_flush_whenever() to gimp_display_flush_update_region() and call gimp_display_shell_flush() separately in the only case we passed FALSE to flush_whenever() - remove th flush_now interval logic from GimpDisplay, as soon as we have exposed the canvas, we are in the loop for the next frame clock tick anyway, so delaying a useless and removed process_updates serves no purpose - in gimptool-progress.c, create the invisible grab widget also for non-cencelable cases, so we can always safely run the main loop manually to make the progress updates visible - in gimp-gegl-apply-operation.c, always run the main loop manually to make the progress updates visible - in gimpstatusbar.c, leave some FIXME comments as reminder that we might need the same logic as in gimptool-progress.c
2018-07-01 22:19:54 +08:00
gimp_progress_start (progress, cancelable, "%s", undo_desc);
app: make gimp_gegl_apply_cached_operation() cancelable via GimpProgress In gimp_drawable_merge_filter(), use that feature to make filter applying cancelable. Stop projection rendering first, because we have to run the event loop manually in order to receive input for canceling, but we don't want the projection to be constructed from that manual loop running.
2014-06-30 06:10:25 +08:00
app: remove all calls to gdk_window_process_updated() - remove gimp_widget_flush_expose() - remove the "now" argument to gimp_display_shell_flush() and make it only update widget states - rename gimp_display_flush_whenever() to gimp_display_flush_update_region() and call gimp_display_shell_flush() separately in the only case we passed FALSE to flush_whenever() - remove th flush_now interval logic from GimpDisplay, as soon as we have exposed the canvas, we are in the loop for the next frame clock tick anyway, so delaying a useless and removed process_updates serves no purpose - in gimptool-progress.c, create the invisible grab widget also for non-cencelable cases, so we can always safely run the main loop manually to make the progress updates visible - in gimp-gegl-apply-operation.c, always run the main loop manually to make the progress updates visible - in gimpstatusbar.c, leave some FIXME comments as reminder that we might need the same logic as in gimptool-progress.c
2018-07-01 22:19:54 +08:00
if (cancelable)
app: make gimp_gegl_apply_cached_operation() cancelable via GimpProgress In gimp_drawable_merge_filter(), use that feature to make filter applying cancelable. Stop projection rendering first, because we have to run the event loop manually in order to receive input for canceling, but we don't want the projection to be constructed from that manual loop running.
2014-06-30 06:10:25 +08:00
g_signal_connect (progress, "cancel",
G_CALLBACK (gimp_gegl_apply_operation_cancel),
&cancel);
progress_started = TRUE;
app: be smarter about progress in gimp_apply_operation() so an already started progress can be passed in.
2012-03-20 06:57:50 +08:00
}
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
}
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
else
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
{
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
cancelable = FALSE;
}
gegl_buffer_freeze_changed (dest_buffer);
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
all_pixels = rect.width * rect.height;
done_pixels = 0;
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
region = cairo_region_create_rectangle ((cairo_rectangle_int_t *) &rect);
if (cache)
{
gint i;
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
for (i = 0; i < n_valid_rects; i++)
{
app: in gimp_gegl_apply_cached_operation(), intersect cached rects with dest rect In gimp_gegl_apply_cached_operation(), intersect the cached rects with the dest rect, so that we don't unnecessarily (if not erroneously) copy cached regions outside the dest rect to the dest buffer. This can happen when the op's applicator crop-rect changes dynamically.
2018-12-30 20:47:47 +08:00
GeglRectangle valid_rect;
if (! gegl_rectangle_intersect (&valid_rect,
&valid_rects[i], &rect))
{
continue;
}
gimp_gegl_buffer_copy (cache, &valid_rect, GEGL_ABYSS_NONE,
dest_buffer, &valid_rect);
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
cairo_region_subtract_rectangle (region,
(cairo_rectangle_int_t *)
app: in gimp_gegl_apply_cached_operation(), intersect cached rects with dest rect In gimp_gegl_apply_cached_operation(), intersect the cached rects with the dest rect, so that we don't unnecessarily (if not erroneously) copy cached regions outside the dest rect to the dest buffer. This can happen when the op's applicator crop-rect changes dynamically.
2018-12-30 20:47:47 +08:00
&valid_rect);
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
app: in gimp_gegl_apply_cached_operation(), intersect cached rects with dest rect In gimp_gegl_apply_cached_operation(), intersect the cached rects with the dest rect, so that we don't unnecessarily (if not erroneously) copy cached regions outside the dest rect to the dest buffer. This can happen when the op's applicator crop-rect changes dynamically.
2018-12-30 20:47:47 +08:00
done_pixels += valid_rect.width * valid_rect.height;
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
if (progress)
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
{
gimp_progress_set_value (progress,
(gdouble) done_pixels /
(gdouble) all_pixels);
}
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
}
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
}
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
iter = gimp_chunk_iterator_new (region);
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
while (gimp_chunk_iterator_next (iter))
{
GeglRectangle render_rect;
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
if (progress)
{
while (! cancel && g_main_context_pending (NULL))
g_main_context_iteration (NULL, FALSE);
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
if (cancel)
break;
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
}
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
while (gimp_chunk_iterator_get_rect (iter, &render_rect))
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
{
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
gint rect_pixels = render_rect.width * render_rect.height;
app: make gimp_gegl_apply_cached_operation() cancelable via GimpProgress In gimp_drawable_merge_filter(), use that feature to make filter applying cancelable. Stop projection rendering first, because we have to run the event loop manually in order to receive input for canceling, but we don't want the projection to be constructed from that manual loop running.
2014-06-30 06:10:25 +08:00
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
gegl_node_blit (dest_node, 1.0, &render_rect, NULL, NULL, 0,
GEGL_BLIT_DEFAULT);
done_pixels += rect_pixels;
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
}
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
if (progress)
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
{
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
gimp_progress_set_value (progress,
(gdouble) done_pixels /
(gdouble) all_pixels);
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
}
app: don't use a GeglProcessor when we don't need a progress Instead, use gegl_node_blit() directly which is more than ten times faster in gimp_gegl_apply_operation(). Patch from Massimo Valentini.
2013-03-03 01:30:22 +08:00
}
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
app: use GimpChunkIterator in gimp_gegl_apply_cached_operation() In gimp_gegl_apply_cached_operation(), replace the use of GeglProcessor with GimpChunkIterator, so that we use the same chunking logic as for rendering projections. This has the advantage of better chunk alignment to the tile grid and dynamic chunk sizing, which improve performance. Use chunking even when there's no progress indication, since it generally results in better cache locality.
2019-01-12 16:41:00 +08:00
gegl_buffer_thaw_changed (dest_buffer);
app: add gimp_gegl_apply_cached_operation() which does the same as gimp_gegl_apply_operation() but takes additional arguments which are a cache buffer and a list of rectangles that specify the already computed region in the cache buffer.
2014-06-19 00:42:17 +08:00
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
g_object_unref (gegl);
app: restore operation src node in gimp_gegl_apply_[cached_]operation() When merging a drawable filter, we call gimp_gegl_apply_cached_operation() on a node that's part of the drawable's filter stack graph. The function rewires the node's input, and doesn't restore its original input connection before returning, leaving the graph in an inconsistent state. Currently, this doesn't matter, since we remove the filter right after that, but the next commit expects the filter stack graph to remain consistent. Remember the original source node of "operation" in gimp_gegl_apply_cached_operation(), and restore it upon exit, to fix that.
2017-12-06 02:34:43 +08:00
if (operation_src_node)
{
gegl_node_connect_to (operation_src_node, "output",
operation, "input");
}
app: make gimp_gegl_apply_cached_operation() cancelable via GimpProgress In gimp_drawable_merge_filter(), use that feature to make filter applying cancelable. Stop projection rendering first, because we have to run the event loop manually in order to receive input for canceling, but we don't want the projection to be constructed from that manual loop running.
2014-06-30 06:10:25 +08:00
if (progress_started)
{
gimp_progress_end (progress);
app: remove all calls to gdk_window_process_updated() - remove gimp_widget_flush_expose() - remove the "now" argument to gimp_display_shell_flush() and make it only update widget states - rename gimp_display_flush_whenever() to gimp_display_flush_update_region() and call gimp_display_shell_flush() separately in the only case we passed FALSE to flush_whenever() - remove th flush_now interval logic from GimpDisplay, as soon as we have exposed the canvas, we are in the loop for the next frame clock tick anyway, so delaying a useless and removed process_updates serves no purpose - in gimptool-progress.c, create the invisible grab widget also for non-cencelable cases, so we can always safely run the main loop manually to make the progress updates visible - in gimp-gegl-apply-operation.c, always run the main loop manually to make the progress updates visible - in gimpstatusbar.c, leave some FIXME comments as reminder that we might need the same logic as in gimptool-progress.c
2018-07-01 22:19:54 +08:00
if (cancelable)
app: make gimp_gegl_apply_cached_operation() cancelable via GimpProgress In gimp_drawable_merge_filter(), use that feature to make filter applying cancelable. Stop projection rendering first, because we have to run the event loop manually in order to receive input for canceling, but we don't want the projection to be constructed from that manual loop running.
2014-06-30 06:10:25 +08:00
g_signal_handlers_disconnect_by_func (progress,
gimp_gegl_apply_operation_cancel,
&cancel);
}
return ! cancel;
app: add gimp_apply_operaion() as generic buffer-to-buffer utility function and use it from gimpdrawable-operation.c
2012-03-16 22:14:35 +08:00
}
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
void
app: use gegl:dither instead of gegl:reduction
2016-12-25 02:39:32 +08:00
gimp_gegl_apply_dither (GeglBuffer *src_buffer,
GimpProgress *progress,
const gchar *undo_desc,
GeglBuffer *dest_buffer,
gint levels,
gint dither_type)
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
{
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));
app: use gegl:dither instead of gegl:reduction
2016-12-25 02:39:32 +08:00
levels = CLAMP (levels, 2, 65536);
app: CLAMP(bits, 1, 16) in gimp_gegl_apply_color_reduction() which is the range of the GEGL op's properties.
2016-11-09 19:33:13 +08:00
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
node = gegl_node_new_child (NULL,
app: use gegl:dither instead of gegl:reduction
2016-12-25 02:39:32 +08:00
"operation", "gegl:dither",
"red-levels", levels,
"green-levels", levels,
"blue-levels", levels,
"alpha-bits", levels,
gegl-apply-operation: s/dither-strategy/dither-method/
2016-09-28 18:05:41 +08:00
"dither-method", dither_type,
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
NULL);
gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
node, dest_buffer, NULL, FALSE);
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
g_object_unref (node);
}
void
app: use the layer's composite space when flattening it Add a composite_space parameter to gimp_gegl_create_flatten_node() and gimp_gegl_apply_flatten(), which controld the color space -- linear or perceptual RGB -- used for the operation (instead of hardcoding it to linear). When removing a layer's alpha channel, use the layer's composite space for the flattening. When flattening an image, use the bottom layer's composite space. Keep using linear space when creating a channel or a mask from a drawable with alpha.
2017-10-21 23:21:10 +08:00
gimp_gegl_apply_flatten (GeglBuffer *src_buffer,
GimpProgress *progress,
const gchar *undo_desc,
GeglBuffer *dest_buffer,
const GimpRGB *background,
Issue #1997 - Colors not properly converted to image's color space Add a Babl space parameter to gimp_gegl_color_new() and all utility functions using it. Pass NULL if the GimpRGB actually is sRGB, pass the image's layer space if the color was already converted using gimp_pickable_srgb_to_image_color() or similar.
2018-08-10 02:04:44 +08:00
const Babl *space,
app: use the layer's composite space when flattening it Add a composite_space parameter to gimp_gegl_create_flatten_node() and gimp_gegl_apply_flatten(), which controld the color space -- linear or perceptual RGB -- used for the operation (instead of hardcoding it to linear). When removing a layer's alpha channel, use the layer's composite space for the flattening. When flattening an image, use the bottom layer's composite space. Keep using linear space when creating a channel or a mask from a drawable with alpha.
2017-10-21 23:21:10 +08:00
GimpLayerColorSpace composite_space)
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
{
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);
Issue #1997 - Colors not properly converted to image's color space Add a Babl space parameter to gimp_gegl_color_new() and all utility functions using it. Pass NULL if the GimpRGB actually is sRGB, pass the image's layer space if the color was already converted using gimp_pickable_srgb_to_image_color() or similar.
2018-08-10 02:04:44 +08:00
node = gimp_gegl_create_flatten_node (background, space, composite_space);
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
node, dest_buffer, NULL, FALSE);
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
g_object_unref (node);
}
app: add gimp_gegl_apply_feather() and use it in gimp_channel_real_feather() so the magic factor of 3.5 to turn feather radius into gegl:gaussian-blur's std_dev is hidden behind an API.
2013-04-08 20:16:33 +08:00
void
Bug 725556 - Feather selection extremely slow gimp_gegl_apply_feather(): add a "dest_rect" parameter to restrict the feather area. Pass the selection bounds plus the feather radius. For consistency, newly add gimp_gegl_apply_border,grow,shrink() and use them in gimpchannel.c
2014-03-05 05:09:11 +08:00
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)
app: add gimp_gegl_apply_feather() and use it in gimp_channel_real_feather() so the magic factor of 3.5 to turn feather radius into gegl:gaussian-blur's std_dev is hidden behind an API.
2013-04-08 20:16:33 +08:00
{
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));
/* 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,
Bug 725556 - Feather selection extremely slow gimp_gegl_apply_feather(): add a "dest_rect" parameter to restrict the feather area. Pass the selection bounds plus the feather radius. For consistency, newly add gimp_gegl_apply_border,grow,shrink() and use them in gimpchannel.c
2014-03-05 05:09:11 +08:00
dest_buffer, dest_rect,
app: add gimp_gegl_apply_feather() and use it in gimp_channel_real_feather() so the magic factor of 3.5 to turn feather radius into gegl:gaussian-blur's std_dev is hidden behind an API.
2013-04-08 20:16:33 +08:00
radius_x / 3.5,
radius_y / 3.5);
}
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
void
app: Modify gimp_gegl_apply_border() to take a style parameter instead of the feather parameter. The BORDER_STYLE_HARD and BORDER_STYLE_FEATHERED styles are implemented using the "gimp:border" operation, as was done previously. The BORDER_STYLE_SMOOTH style is implemented by performing a "gimp:grow" and a "gimp:shrink", and subtracting the shrunk image from the grown image using "gegl:substract". gimp_channel_border() is modified to pass either BORDER_STYLE_HARD or BORDER_STYLE_FEATHER, depending on its feather parameter, to maintain the current behavior. The next commit replaces it with a style parameter as well. Mass parameter alignment changes to gimp-gegl-apply-operation.h. Sigh...
2016-04-04 23:11:05 +08:00
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)
Bug 725556 - Feather selection extremely slow gimp_gegl_apply_feather(): add a "dest_rect" parameter to restrict the feather area. Pass the selection bounds plus the feather radius. For consistency, newly add gimp_gegl_apply_border,grow,shrink() and use them in gimpchannel.c
2014-03-05 05:09:11 +08:00
{
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));
app: Modify gimp_gegl_apply_border() to take a style parameter instead of the feather parameter. The BORDER_STYLE_HARD and BORDER_STYLE_FEATHERED styles are implemented using the "gimp:border" operation, as was done previously. The BORDER_STYLE_SMOOTH style is implemented by performing a "gimp:grow" and a "gimp:shrink", and subtracting the shrunk image from the grown image using "gegl:substract". gimp_channel_border() is modified to pass either BORDER_STYLE_HARD or BORDER_STYLE_FEATHER, depending on its feather parameter, to maintain the current behavior. The next commit replaces it with a style parameter as well. Mass parameter alignment changes to gimp-gegl-apply-operation.h. Sigh...
2016-04-04 23:11:05 +08:00
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:
app: replace all g_assert() by the newly added gimp_assert() which is just a #define to g_assert for now, but can now easily be turned into something that does some nicer debugging using our new stack trace infrastructure. This commit also reverts all constructed() functions to use assert again.
2018-02-12 05:23:10 +08:00
gimp_assert_not_reached ();
app: Modify gimp_gegl_apply_border() to take a style parameter instead of the feather parameter. The BORDER_STYLE_HARD and BORDER_STYLE_FEATHERED styles are implemented using the "gimp:border" operation, as was done previously. The BORDER_STYLE_SMOOTH style is implemented by performing a "gimp:grow" and a "gimp:shrink", and subtracting the shrunk image from the grown image using "gegl:substract". gimp_channel_border() is modified to pass either BORDER_STYLE_HARD or BORDER_STYLE_FEATHER, depending on its feather parameter, to maintain the current behavior. The next commit replaces it with a style parameter as well. Mass parameter alignment changes to gimp-gegl-apply-operation.h. Sigh...
2016-04-04 23:11:05 +08:00
}
Bug 725556 - Feather selection extremely slow gimp_gegl_apply_feather(): add a "dest_rect" parameter to restrict the feather area. Pass the selection bounds plus the feather radius. For consistency, newly add gimp_gegl_apply_border,grow,shrink() and use them in gimpchannel.c
2014-03-05 05:09:11 +08:00
gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
app: crop input to output rect in channel ops In gimp_gegl_apply_{border,grow,shrink,flood}(), which are used by the corresponding channel functions, pass crop_input = TRUE to gimp_gegl_apply_operation(), to clip the input to the output rect. These operations process the entire input in one go, regardless of the requested output region; however, the channel functions calculate the output region according to the known channel bounds, hence clipping the input to these bounds doesn't affect discard any information, while avoiding unnecessary work. In particular, this makes the corresponding operations on small selections in big images much faster.
2018-03-23 01:38:11 +08:00
node, dest_buffer, dest_rect, TRUE);
Bug 725556 - Feather selection extremely slow gimp_gegl_apply_feather(): add a "dest_rect" parameter to restrict the feather area. Pass the selection bounds plus the feather radius. For consistency, newly add gimp_gegl_apply_border,grow,shrink() and use them in gimpchannel.c
2014-03-05 05:09:11 +08:00
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,
app: crop input to output rect in channel ops In gimp_gegl_apply_{border,grow,shrink,flood}(), which are used by the corresponding channel functions, pass crop_input = TRUE to gimp_gegl_apply_operation(), to clip the input to the output rect. These operations process the entire input in one go, regardless of the requested output region; however, the channel functions calculate the output region according to the known channel bounds, hence clipping the input to these bounds doesn't affect discard any information, while avoiding unnecessary work. In particular, this makes the corresponding operations on small selections in big images much faster.
2018-03-23 01:38:11 +08:00
node, dest_buffer, dest_rect, TRUE);
Bug 725556 - Feather selection extremely slow gimp_gegl_apply_feather(): add a "dest_rect" parameter to restrict the feather area. Pass the selection bounds plus the feather radius. For consistency, newly add gimp_gegl_apply_border,grow,shrink() and use them in gimpchannel.c
2014-03-05 05:09:11 +08:00
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,
app: crop input to output rect in channel ops In gimp_gegl_apply_{border,grow,shrink,flood}(), which are used by the corresponding channel functions, pass crop_input = TRUE to gimp_gegl_apply_operation(), to clip the input to the output rect. These operations process the entire input in one go, regardless of the requested output region; however, the channel functions calculate the output region according to the known channel bounds, hence clipping the input to these bounds doesn't affect discard any information, while avoiding unnecessary work. In particular, this makes the corresponding operations on small selections in big images much faster.
2018-03-23 01:38:11 +08:00
node, dest_buffer, dest_rect, TRUE);
Bug 725556 - Feather selection extremely slow gimp_gegl_apply_feather(): add a "dest_rect" parameter to restrict the feather area. Pass the selection bounds plus the feather radius. For consistency, newly add gimp_gegl_apply_border,grow,shrink() and use them in gimpchannel.c
2014-03-05 05:09:11 +08:00
g_object_unref (node);
}
app: Add "gimp:flood" GEGL operation This operation assigns to each pixel the minimum of the maxima of all paths from it to the outside, as if the input image represents a height map, and the operation floods it with water.
2016-01-25 01:08:43 +08:00
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,
app: crop input to output rect in channel ops In gimp_gegl_apply_{border,grow,shrink,flood}(), which are used by the corresponding channel functions, pass crop_input = TRUE to gimp_gegl_apply_operation(), to clip the input to the output rect. These operations process the entire input in one go, regardless of the requested output region; however, the channel functions calculate the output region according to the known channel bounds, hence clipping the input to these bounds doesn't affect discard any information, while avoiding unnecessary work. In particular, this makes the corresponding operations on small selections in big images much faster.
2018-03-23 01:38:11 +08:00
node, dest_buffer, dest_rect, TRUE);
app: Add "gimp:flood" GEGL operation This operation assigns to each pixel the minimum of the maxima of all paths from it to the outside, as if the input image represents a height map, and the operation floods it with water.
2016-01-25 01:08:43 +08:00
g_object_unref (node);
}
Bug 725556 - Feather selection extremely slow gimp_gegl_apply_feather(): add a "dest_rect" parameter to restrict the feather area. Pass the selection bounds plus the feather radius. For consistency, newly add gimp_gegl_apply_border,grow,shrink() and use them in gimpchannel.c
2014-03-05 05:09:11 +08:00
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)
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
{
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,
NULL);
gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
node, dest_buffer, dest_rect, FALSE);
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
g_object_unref (node);
}
void
app: follow the GEGL invert -> invert-linear vs. invert-gamma change and invert masks using invert-linear and other drawables using invert-gamma. drawable_invert_cmd_callback() still always uses invert-gamma even though it can be used on layer masks.
2013-06-24 06:45:04 +08:00
gimp_gegl_apply_invert_gamma (GeglBuffer *src_buffer,
GimpProgress *progress,
const gchar *undo_desc,
GeglBuffer *dest_buffer)
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
{
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,
app: follow the GEGL invert -> invert-linear vs. invert-gamma change and invert masks using invert-linear and other drawables using invert-gamma. drawable_invert_cmd_callback() still always uses invert-gamma even though it can be used on layer masks.
2013-06-24 06:45:04 +08:00
"operation", "gegl:invert-gamma",
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
NULL);
gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
node, dest_buffer, NULL, FALSE);
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
g_object_unref (node);
}
app: follow the GEGL invert -> invert-linear vs. invert-gamma change and invert masks using invert-linear and other drawables using invert-gamma. drawable_invert_cmd_callback() still always uses invert-gamma even though it can be used on layer masks.
2013-06-24 06:45:04 +08:00
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,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
node, dest_buffer, NULL, FALSE);
app: follow the GEGL invert -> invert-linear vs. invert-gamma change and invert masks using invert-linear and other drawables using invert-gamma. drawable_invert_cmd_callback() still always uses invert-gamma even though it can be used on layer masks.
2013-06-24 06:45:04 +08:00
g_object_unref (node);
}
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
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,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
node, dest_buffer, NULL, FALSE);
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
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,
Bug 793734 - White alpha border after upscaling In gimp_gegl_apply_scale(), use a CLAMP abyss policy for the scale op, to avoid leaking transparency into the image when scaling drawables. Note that this (intentionally) only affects whole-image/layer scaling, and not scaling done using any of the transform tools.
2018-03-23 04:53:08 +08:00
"operation", "gegl:scale-ratio",
"origin-x", 0.0,
"origin-y", 0.0,
"sampler", interpolation_type,
"abyss-policy", GEGL_ABYSS_CLAMP,
"x", x,
"y", y,
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
NULL);
gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
node, dest_buffer, NULL, FALSE);
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
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,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
node, dest_buffer, NULL, FALSE);
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
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,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
node, dest_buffer, NULL, FALSE);
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
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,
app: use gimp_transform_polygon() in gimp_transform_resize_boundary() ... so that the transformed boundary is properly clipped. Adjust the boundary-size algorithms to operate on arbitrary polygons. Avoid using gimp_matrix3_will_explode() in gimp_drawable_transform_buffer_affine() and falling back to cropping the result, and avoid setting the "clip-to-input" property of gegl:transform. Neither of those in needed anymore. This effectively reverts the app/ part of commit 768d06614f203bf555bbda1f6186d4730ae2f8b5. The next commit revets the libgimpmath/ part.
2018-01-29 03:50:13 +08:00
"operation", "gegl:transform",
app: pass near-plane z-coordinate to gegl:transform ... so that GEGL performs the same clipping we do.
2018-01-29 04:53:01 +08:00
"near-z", GIMP_TRANSFORM_NEAR_Z,
app: use gimp_transform_polygon() in gimp_transform_resize_boundary() ... so that the transformed boundary is properly clipped. Adjust the boundary-size algorithms to operate on arbitrary polygons. Avoid using gimp_matrix3_will_explode() in gimp_drawable_transform_buffer_affine() and falling back to cropping the result, and avoid setting the "clip-to-input" property of gegl:transform. Neither of those in needed anymore. This effectively reverts the app/ part of commit 768d06614f203bf555bbda1f6186d4730ae2f8b5. The next commit revets the libgimpmath/ part.
2018-01-29 03:50:13 +08:00
"sampler", interpolation_type,
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
NULL);
gimp_gegl_node_set_matrix (node, transform);
gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
app: add crop_input parameter to gimp_gegl_apply_operation() Add a crop_input parameter to gimp_gegl_apply_[cached_]operation(). When TRUE, the functions crop the op's input to the destination rect. This is particularly useful for functions that process the entire input in one go (by means of get_cached_region()). See the next commit. Pass crop_input = FALSE at all call sites for now, to keep the current behavior.
2018-03-23 01:31:00 +08:00
node, dest_buffer, NULL, FALSE);
app: add utility functions for applying specific operations to buffers so gimp_gegl_apply_foo() will run "gegl:foo" with the required properties on a buffer and write the result to another buffer.
2012-11-01 06:47:45 +08:00
g_object_unref (node);
}