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

721 lines
25 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
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#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"
#include "core/gimpprogress.h"
#include "gimp-gegl-apply-operation.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"
#include "gegl/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,
const GeglRectangle *dest_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
{
gimp_gegl_apply_cached_operation (src_buffer,
progress, undo_desc,
operation,
dest_buffer,
dest_rect,
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,
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: some GimpProgress cleanup - change start() and set_text() to use "format" and "..." instead of "message", allowing to format progress messages in place - s/cancelable/cancellable/ - move "cancellable" to be the second argument of start()
2014-07-13 05:45:20 +08:00
gboolean cancellable)
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
{
GeglNode *gegl;
GeglNode *dest_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
GeglNode *operation_src_node = NULL;
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
GeglRectangle rect = { 0, };
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
GeglProcessor *processor = NULL;
gboolean progress_started = 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
gdouble value;
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
gboolean cancel = 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: 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: support src ops in gimp_gegl_apply_operation()
2013-09-13 15:42:53 +08:00
if (src_buffer && gegl_node_has_pad (operation, "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
{
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
* work with area ops when using a processor. See bug #701875.
*/
if (progress && (src_buffer == dest_buffer))
src_buffer = gegl_buffer_dup (src_buffer);
else
g_object_ref (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
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: 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: 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
gegl_node_connect_to (src_node, "output",
operation, "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
dest_node = gegl_node_new_child (gegl,
"operation", "gegl:write-buffer",
"buffer", dest_buffer,
NULL);
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
gegl_node_connect_to (operation, "output",
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: 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
processor = gegl_node_new_processor (dest_node, &rect);
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: some GimpProgress cleanup - change start() and set_text() to use "format" and "..." instead of "message", allowing to format progress messages in place - s/cancelable/cancellable/ - move "cancellable" to be the second argument of start()
2014-07-13 05:45:20 +08:00
cancellable = 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: some GimpProgress cleanup - change start() and set_text() to use "format" and "..." instead of "message", allowing to format progress messages in place - s/cancelable/cancellable/ - move "cancellable" to be the second argument of start()
2014-07-13 05:45:20 +08:00
gimp_progress_start (progress, cancellable, "%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: some GimpProgress cleanup - change start() and set_text() to use "format" and "..." instead of "message", allowing to format progress messages in place - s/cancelable/cancellable/ - move "cancellable" to be the second argument of start()
2014-07-13 05:45:20 +08:00
if (cancellable)
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
}
if (cache)
{
cairo_region_t *region;
gint all_pixels;
gint done_pixels = 0;
gint n_rects;
gint i;
region = cairo_region_create_rectangle ((cairo_rectangle_int_t *) &rect);
all_pixels = rect.width * rect.height;
for (i = 0; i < n_valid_rects; i++)
{
follow gegl api changes from commit af5361ca8d, with an abyss policy argument to gegl_buffer_copy.
2015-05-25 04:32:55 +08:00
gegl_buffer_copy (cache, valid_rects + i, GEGL_ABYSS_NONE,
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
dest_buffer, valid_rects + i);
cairo_region_subtract_rectangle (region,
(cairo_rectangle_int_t *)
valid_rects + i);
done_pixels += valid_rects[i].width * valid_rects[i].height;
if (progress)
gimp_progress_set_value (progress,
(gdouble) done_pixels /
(gdouble) all_pixels);
}
n_rects = cairo_region_num_rectangles (region);
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
for (i = 0; ! cancel && (i < n_rects); 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
{
cairo_rectangle_int_t 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: 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_get_rectangle (region, i, &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: 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)
{
gint rect_pixels = render_rect.width * render_rect.height;
#ifdef REUSE_PROCESSOR
gegl_processor_set_rectangle (processor,
(GeglRectangle *) &render_rect);
#else
g_object_unref (processor);
processor = gegl_node_new_processor (dest_node,
(GeglRectangle *) &render_rect);
#endif
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
while (! cancel && gegl_processor_work (processor, &value))
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_progress_set_value (progress,
((gdouble) done_pixels +
value * rect_pixels) /
(gdouble) all_pixels);
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: some GimpProgress cleanup - change start() and set_text() to use "format" and "..." instead of "message", allowing to format progress messages in place - s/cancelable/cancellable/ - move "cancellable" to be the second argument of start()
2014-07-13 05:45:20 +08:00
if (cancellable)
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
while (! cancel && g_main_context_pending (NULL))
g_main_context_iteration (NULL, 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
}
done_pixels += rect_pixels;
}
else
{
gegl_node_blit (dest_node, 1.0, (GeglRectangle *) &render_rect,
NULL, NULL, 0, GEGL_BLIT_DEFAULT);
}
}
cairo_region_destroy (region);
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
}
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
if (progress)
{
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
while (! cancel && gegl_processor_work (processor, &value))
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_progress_set_value (progress, value);
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: some GimpProgress cleanup - change start() and set_text() to use "format" and "..." instead of "message", allowing to format progress messages in place - s/cancelable/cancellable/ - move "cancellable" to be the second argument of start()
2014-07-13 05:45:20 +08:00
if (cancellable)
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
while (! cancel && g_main_context_pending (NULL))
g_main_context_iteration (NULL, 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
}
}
else
{
gegl_node_blit (dest_node, 1.0, &rect,
NULL, NULL, 0, GEGL_BLIT_DEFAULT);
}
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: 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 (processor)
g_object_unref (processor);
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: some GimpProgress cleanup - change start() and set_text() to use "format" and "..." instead of "message", allowing to format progress messages in place - s/cancelable/cancellable/ - move "cancellable" to be the second argument of start()
2014-07-13 05:45:20 +08:00
if (cancellable)
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,
node, dest_buffer, NULL);
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,
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);
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
node = gimp_gegl_create_flatten_node (background, 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,
node, dest_buffer, NULL);
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,
node, dest_buffer, dest_rect);
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);
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);
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,
node, dest_buffer, dest_rect);
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,
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
node, dest_buffer, dest_rect);
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,
node, dest_buffer, NULL);
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,
node, dest_buffer, NULL);
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,
node, dest_buffer, NULL);
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,
app: Use gegl:scale-ratio instead of the deprecated gegl:scale
2013-06-10 01:51:16 +08:00
"operation", "gegl:scale-ratio",
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
"origin-x", 0.0,
"origin-y", 0.0,
app: adapt to the transform ops API change in GEGL
2013-06-07 01:56:06 +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
"x", x,
"y", y,
NULL);
gimp_gegl_apply_operation (src_buffer, progress, undo_desc,
node, dest_buffer, NULL);
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);
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);
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,
node, dest_buffer, NULL);
g_object_unref (node);
}