static void gimp_cage_tool_compute_coef (GimpCageTool *ct) { GimpCageConfig *config = ct->config; GimpProgress *progress; const Babl *format; GeglNode *gegl; GeglNode *input; GeglNode *output; GeglProcessor *processor; GeglBuffer *buffer; gdouble value; progress = gimp_progress_start (GIMP_PROGRESS (ct), _("Computing Cage Coefficients"), FALSE); if (ct->coef) { g_object_unref (ct->coef); ct->coef = NULL; } format = babl_format_n (babl_type ("float"), gimp_cage_config_get_n_points (config) * 2); gegl = gegl_node_new (); input = gegl_node_new_child (gegl, "operation", "gimp:cage-coef-calc", "config", ct->config, NULL); output = gegl_node_new_child (gegl, "operation", "gegl:buffer-sink", "buffer", &buffer, "format", format, NULL); gegl_node_connect_to (input, "output", output, "input"); processor = gegl_node_new_processor (output, NULL); while (gegl_processor_work (processor, &value)) { if (progress) gimp_progress_set_value (progress, value); } if (progress) gimp_progress_end (progress); g_object_unref (processor); ct->coef = buffer; g_object_unref (gegl); ct->dirty_coef = FALSE; }
static void gimp_projection_construct_gegl (GimpProjection *proj, gint x, gint y, gint w, gint h) { GeglNode *sink; GeglRectangle rect; sink = gimp_projection_get_sink_node (proj); rect.x = x; rect.y = y; rect.width = w; rect.height = h; if (! proj->processor) proj->processor = gegl_node_new_processor (sink, &rect); else gegl_processor_set_rectangle (proj->processor, &rect); while (gegl_processor_work (proj->processor, NULL)); /* FIXME: Reuse it when it can handle dirty rects when painting * properly */ g_object_unref (proj->processor); proj->processor = NULL; }
int dt_dev_pixelpipe_process(dt_dev_pixelpipe_t *pipe, dt_develop_t *dev, int x, int y, int width, int height, float scale) { pipe->processing = 1; printf("pixelpipe process start\n"); // have backbuf in right size: if(pipe->backbuf_size < width*height*4*sizeof(uint8_t)) { pthread_mutex_lock(&pipe->backbuf_mutex); pipe->backbuf_size = width*height*4*sizeof(uint8_t); free(pipe->backbuf); pipe->backbuf = (uint8_t *)dt_alloc_align(16, pipe->backbuf_size); pthread_mutex_unlock(&pipe->backbuf_mutex); } // scale node (is slow): // scale *= 2; // FIXME: this seems to be a bug in gegl. need to manually adjust updated roi here. GeglRectangle roi = (GeglRectangle) { x, y, width, height }; GeglRectangle roio = (GeglRectangle) { roi.x/scale, roi.y/scale, roi.width/scale, roi.height/scale }; roio.x = MAX(0, roio.x); roio.y = MAX(0, roio.y); roio.width = MIN(pipe->iwidth -roio.x-1, roio.width); roio.height = MIN(pipe->iheight-roio.y-1, roio.height); GeglProcessor *processor = gegl_node_new_processor (pipe->output, &roio); // gegl_node_set(pipe->scale, "x", scale, "y", scale, NULL); // GeglProcessor *processor = gegl_node_new_processor (pipe->output, roi); double progress; // TODO: insert constant scale node at beginning, maintain lo-res branch of pipeline (shadowed). // TODO: decide on scale param, which one to use. while (gegl_processor_work (processor, &progress)) { // if history changed, abort processing? if(pipe->changed != DT_DEV_PIPE_UNCHANGED || dev->gui_leaving) return 1; } gegl_processor_destroy (processor); // gegl scale node turned out to be even slower :( gegl_node_blit (pipe->output, scale, &roi, babl_format("RGBA u8"), pipe->backbuf, GEGL_AUTO_ROWSTRIDE, GEGL_BLIT_CACHE); // gegl_node_blit (pipe->output, 1.0, roi, babl_format("RGBA u8"), output, GEGL_AUTO_ROWSTRIDE, GEGL_BLIT_CACHE); // TODO: update histograms here with this data? printf("pixelpipe process end\n"); pipe->processing = 0; return 0; }
void gimp_applicator_apply (GimpApplicator *applicator, GeglBuffer *src_buffer, GeglBuffer *apply_buffer, gint apply_buffer_x, gint apply_buffer_y, gdouble opacity, GimpLayerModeEffects paint_mode) { gint width = gegl_buffer_get_width (apply_buffer); gint height = gegl_buffer_get_height (apply_buffer); if (applicator->src_buffer != src_buffer) { applicator->src_buffer = src_buffer; gegl_node_set (applicator->src_node, "buffer", src_buffer, NULL); } if (applicator->apply_buffer != apply_buffer) { applicator->apply_buffer = apply_buffer; gegl_node_set (applicator->apply_src_node, "buffer", apply_buffer, NULL); } gegl_node_set (applicator->apply_offset_node, "x", (gdouble) apply_buffer_x, "y", (gdouble) apply_buffer_y, NULL); if ((applicator->opacity != opacity) || (applicator->paint_mode != paint_mode)) { applicator->opacity = opacity; applicator->paint_mode = paint_mode; gimp_gegl_mode_node_set (applicator->mode_node, paint_mode, opacity, FALSE); } gegl_processor_set_rectangle (applicator->processor, GEGL_RECTANGLE (apply_buffer_x, apply_buffer_y, width, height)); while (gegl_processor_work (applicator->processor, NULL)); }
static void gimp_drawable_apply_operation_private (GimpDrawable *drawable, GimpProgress *progress, const gchar *undo_desc, GeglNode *operation, gboolean linear, TileManager *dest_tiles, const GeglRectangle *rect) { GeglNode *gegl; GeglNode *input; GeglNode *output; GeglProcessor *processor; gdouble value; gegl = gegl_node_new (); /* Disable caching on all children of the node unless explicitly re-enabled. */ g_object_set (gegl, "dont-cache", TRUE, NULL); input = gegl_node_new_child (gegl, "operation", "gimp:tilemanager-source", "tile-manager", gimp_drawable_get_tiles (drawable), "linear", linear, NULL); output = gegl_node_new_child (gegl, "operation", "gimp:tilemanager-sink", "tile-manager", dest_tiles, "linear", linear, NULL); gegl_node_add_child (gegl, operation); gegl_node_link_many (input, operation, output, NULL); processor = gegl_node_new_processor (output, rect); if (progress) gimp_progress_start (progress, undo_desc, FALSE); while (gegl_processor_work (processor, &value)) if (progress) gimp_progress_set_value (progress, value); g_object_unref (processor); g_object_unref (gegl); }
static gboolean paint_release (GtkWidget *widget, GdkEventButton *event) { if (event->button == 1) { gdouble x0, x1, y0, y1; GeglProcessor *processor; GeglNode *writebuf; GeglRectangle roi; gegl_path_get_bounds (vector, &x0, &x1, &y0, &y1); roi.x = x0 - LINEWIDTH; roi.y = y0 - LINEWIDTH; roi.width = x1 - x0 + LINEWIDTH * 2; roi.height = y1 - y0 + LINEWIDTH * 2; writebuf = gegl_node_new_child (gegl, "operation", "gegl:write-buffer", "buffer", buffer, NULL); gegl_node_link_many (over, writebuf, NULL); processor = gegl_node_new_processor (writebuf, &roi); while (gegl_processor_work (processor, NULL)) ; gegl_processor_destroy (processor); g_object_unref (writebuf); gegl_node_link_many (top, out, NULL); g_object_unref (over); g_object_unref (stroke); over = NULL; stroke = NULL; pen_down = FALSE; return TRUE; } return FALSE; }
static gboolean test_change_processor_rect_do_test (GeglProcessor *processor, const GeglRectangle *rect, GeglNode *sink) { gint i = 0; gboolean result = TRUE; float expected_result_buffer[4] = { 1.0, 1.0, 1.0, 1.0 }; float result_buffer[4] = { 0, }; GeglBuffer *buffer = NULL; gegl_node_set (sink, "buffer", &buffer, NULL); gegl_processor_set_rectangle (processor, rect); while (gegl_processor_work (processor, NULL)); gegl_buffer_get (buffer, rect, 1.0, babl_format ("RGBA float"), result_buffer, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); /* Compare with a small epsilon to account for accumulated error */ for(i = 0; i < G_N_ELEMENTS (expected_result_buffer); i++) result = result && FLOATS_EQUAL (expected_result_buffer[i], result_buffer[i]); gegl_node_set (sink, "buffer", NULL, NULL); g_object_unref (buffer); return result; }
static gboolean task_monitor(ViewHelper *self) { if (!self->processor || !self->node) { return FALSE; } // PERFORMANCE: combine all the rects added to the queue during a single // iteration of the main loop somehow if (!self->currently_processed_rect) { if (g_queue_is_empty(self->processing_queue)) { // Unregister worker self->monitor_id = 0; return FALSE; } else { // Fetch next rect to process self->currently_processed_rect = (GeglRectangle *)g_queue_pop_tail(self->processing_queue); g_assert(self->currently_processed_rect); gegl_processor_set_rectangle(self->processor, self->currently_processed_rect); } } gboolean processing_done = !gegl_processor_work(self->processor, NULL); if (processing_done) { // Go to next region if (self->currently_processed_rect) { g_free(self->currently_processed_rect); } self->currently_processed_rect = NULL; } return TRUE; }
static void gimp_seamless_clone_tool_filter_update (GimpSeamlessCloneTool *sc) { GimpTool *tool = GIMP_TOOL (sc); GimpDisplayShell *shell = gimp_display_get_shell (tool->display); GimpItem *item = GIMP_ITEM (tool->drawable); gint x, y; gint w, h; gint off_x, off_y; GeglRectangle visible; GeglOperation *op = NULL; GimpProgress *progress; GeglNode *output; GeglProcessor *processor; gdouble value; progress = gimp_progress_start (GIMP_PROGRESS (sc), FALSE, _("Cloning the foreground object")); /* Find out at which x,y is the top left corner of the currently * displayed part */ gimp_display_shell_untransform_viewport (shell, &x, &y, &w, &h); /* Find out where is our drawable positioned */ gimp_item_get_offset (item, &off_x, &off_y); /* Create a rectangle from the intersection of the currently displayed * part with the drawable */ gimp_rectangle_intersect (x, y, w, h, off_x, off_y, gimp_item_get_width (item), gimp_item_get_height (item), &visible.x, &visible.y, &visible.width, &visible.height); /* Since the filter_apply function receives a rectangle describing * where it should update the preview, and since that rectangle should * be relative to the drawable's location, we now offset back by the * drawable's offsetts. */ visible.x -= off_x; visible.y -= off_y; g_object_get (sc->sc_node, "gegl-operation", &op, NULL); /* If any cache of the visible area was present, clear it! * We need to clear the cache in the sc_node, since that is * where the previous paste was located */ gegl_operation_invalidate (op, &visible, TRUE); g_object_unref (op); /* Now update the image map and show this area */ gimp_drawable_filter_apply (sc->filter, NULL); /* Show update progress. */ output = gegl_node_get_output_proxy (sc->render_node, "output"); processor = gegl_node_new_processor (output, NULL); while (gegl_processor_work (processor, &value)) { if (progress) gimp_progress_set_value (progress, value); } if (progress) gimp_progress_end (progress); g_object_unref (processor); }
void gimp_gegl_apply_operation (GeglBuffer *src_buffer, GimpProgress *progress, const gchar *undo_desc, GeglNode *operation, GeglBuffer *dest_buffer, const GeglRectangle *dest_rect) { GeglNode *gegl; GeglNode *dest_node; GeglRectangle rect = { 0, }; gdouble value; gboolean progress_active = FALSE; g_return_if_fail (src_buffer == NULL || GEGL_IS_BUFFER (src_buffer)); g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress)); g_return_if_fail (GEGL_IS_NODE (operation)); g_return_if_fail (GEGL_IS_BUFFER (dest_buffer)); if (dest_rect) { rect = *dest_rect; } else { rect = *GEGL_RECTANGLE (0, 0, gegl_buffer_get_width (dest_buffer), gegl_buffer_get_height (dest_buffer)); } gegl = gegl_node_new (); if (! gegl_node_get_parent (operation)) gegl_node_add_child (gegl, operation); if (src_buffer && gegl_node_has_pad (operation, "input")) { GeglNode *src_node; /* 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); src_node = gegl_node_new_child (gegl, "operation", "gegl:buffer-source", "buffer", src_buffer, NULL); g_object_unref (src_buffer); gegl_node_connect_to (src_node, "output", operation, "input"); } dest_node = gegl_node_new_child (gegl, "operation", "gegl:write-buffer", "buffer", dest_buffer, NULL); gegl_node_connect_to (operation, "output", dest_node, "input"); if (progress) { GeglProcessor *processor; processor = gegl_node_new_processor (dest_node, &rect); progress_active = gimp_progress_is_active (progress); if (progress_active) { if (undo_desc) gimp_progress_set_text (progress, undo_desc); } else { gimp_progress_start (progress, undo_desc, FALSE); } while (gegl_processor_work (processor, &value)) gimp_progress_set_value (progress, value); g_object_unref (processor); } else { gegl_node_blit (dest_node, 1.0, &rect, NULL, NULL, 0, GEGL_BLIT_DEFAULT); } g_object_unref (gegl); if (progress && ! progress_active) gimp_progress_end (progress); }
static void gimp_foreground_select_tool_preview (GimpForegroundSelectTool *fg_select, GimpDisplay *display) { GimpTool *tool = GIMP_TOOL (fg_select); GimpForegroundSelectOptions *options = GIMP_FOREGROUND_SELECT_TOOL_GET_OPTIONS (tool); GimpImage *image = gimp_display_get_image (display); GimpDrawable *drawable = gimp_image_get_active_drawable (image); GeglBuffer *trimap_buffer; GeglBuffer *drawable_buffer; GeglNode *gegl; GeglNode *matting_node; GeglNode *input_image; GeglNode *input_trimap; GeglNode *output_mask; GeglBuffer *buffer; GimpProgress *progress; GeglProcessor *processor; gdouble value; if (fg_select->mask) { g_object_unref (fg_select->mask); fg_select->mask = NULL; } progress = gimp_progress_start (GIMP_PROGRESS (fg_select), _("Computing alpha of unknown pixels"), FALSE); trimap_buffer = fg_select->trimap; drawable_buffer = gimp_drawable_get_buffer (drawable); gegl = gegl_node_new (); input_trimap = gegl_node_new_child (gegl, "operation", "gegl:buffer-source", "buffer", trimap_buffer, NULL); input_image = gegl_node_new_child (gegl, "operation", "gegl:buffer-source", "buffer", drawable_buffer, NULL); output_mask = gegl_node_new_child (gegl, "operation", "gegl:buffer-sink", "buffer", &buffer, "format", NULL, NULL); if (options->engine == GIMP_MATTING_ENGINE_GLOBAL) { matting_node = gegl_node_new_child (gegl, "operation", "gegl:matting-global", "iterations", options->iterations, NULL); } else { matting_node = gegl_node_new_child (gegl, "operation", "gegl:matting-levin", "levels", options->levels, "active_levels", options->active_levels, NULL); } gegl_node_connect_to (input_image, "output", matting_node, "input"); gegl_node_connect_to (input_trimap, "output", matting_node, "aux"); gegl_node_connect_to (matting_node, "output", output_mask, "input"); processor = gegl_node_new_processor (output_mask, NULL); while (gegl_processor_work (processor, &value)) { if (progress) gimp_progress_set_value (progress, value); } if (progress) gimp_progress_end (progress); g_object_unref (processor); fg_select->mask = buffer; gimp_foreground_select_tool_set_preview (fg_select, display); g_object_unref (gegl); }
GeglBuffer * gimp_drawable_foreground_extract (GimpDrawable *drawable, GimpMattingEngine engine, gint global_iterations, gint levin_levels, gint levin_active_levels, GeglBuffer *trimap, GimpProgress *progress) { GeglBuffer *drawable_buffer; GeglNode *gegl; GeglNode *input_node; GeglNode *trimap_node; GeglNode *matting_node; GeglNode *output_node; GeglBuffer *buffer; GeglProcessor *processor; gdouble value; g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (GEGL_IS_BUFFER (trimap), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); progress = gimp_progress_start (progress, FALSE, _("Computing alpha of unknown pixels")); drawable_buffer = gimp_drawable_get_buffer (drawable); gegl = gegl_node_new (); trimap_node = gegl_node_new_child (gegl, "operation", "gegl:buffer-source", "buffer", trimap, NULL); input_node = gegl_node_new_child (gegl, "operation", "gegl:buffer-source", "buffer", drawable_buffer, NULL); output_node = gegl_node_new_child (gegl, "operation", "gegl:buffer-sink", "buffer", &buffer, "format", NULL, NULL); if (engine == GIMP_MATTING_ENGINE_GLOBAL) { matting_node = gegl_node_new_child (gegl, "operation", "gegl:matting-global", "iterations", global_iterations, NULL); } else { matting_node = gegl_node_new_child (gegl, "operation", "gegl:matting-levin", "levels", levin_levels, "active_levels", levin_active_levels, NULL); } gegl_node_connect_to (input_node, "output", matting_node, "input"); gegl_node_connect_to (trimap_node, "output", matting_node, "aux"); gegl_node_connect_to (matting_node, "output", output_node, "input"); processor = gegl_node_new_processor (output_node, NULL); while (gegl_processor_work (processor, &value)) { if (progress) gimp_progress_set_value (progress, value); } if (progress) gimp_progress_end (progress); g_object_unref (processor); g_object_unref (gegl); return buffer; }
gboolean 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, gint n_valid_rects, gboolean cancellable) { GeglNode *gegl; GeglNode *dest_node; GeglRectangle rect = { 0, }; GeglProcessor *processor = NULL; gboolean progress_started = FALSE; gdouble value; gboolean cancel = FALSE; g_return_val_if_fail (src_buffer == NULL || GEGL_IS_BUFFER (src_buffer), FALSE); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE); g_return_val_if_fail (GEGL_IS_NODE (operation), FALSE); g_return_val_if_fail (GEGL_IS_BUFFER (dest_buffer), FALSE); g_return_val_if_fail (cache == NULL || GEGL_IS_BUFFER (cache), FALSE); g_return_val_if_fail (valid_rects == NULL || cache != NULL, FALSE); g_return_val_if_fail (valid_rects == NULL || n_valid_rects != 0, FALSE); if (dest_rect) { rect = *dest_rect; } else { rect = *GEGL_RECTANGLE (0, 0, gegl_buffer_get_width (dest_buffer), gegl_buffer_get_height (dest_buffer)); } gegl = gegl_node_new (); if (! gegl_node_get_parent (operation)) gegl_node_add_child (gegl, operation); if (src_buffer && gegl_node_has_pad (operation, "input")) { GeglNode *src_node; /* 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); src_node = gegl_node_new_child (gegl, "operation", "gegl:buffer-source", "buffer", src_buffer, NULL); g_object_unref (src_buffer); gegl_node_connect_to (src_node, "output", operation, "input"); } dest_node = gegl_node_new_child (gegl, "operation", "gegl:write-buffer", "buffer", dest_buffer, NULL); gegl_node_connect_to (operation, "output", dest_node, "input"); if (progress) { processor = gegl_node_new_processor (dest_node, &rect); if (gimp_progress_is_active (progress)) { if (undo_desc) gimp_progress_set_text_literal (progress, undo_desc); progress_started = FALSE; cancellable = FALSE; } else { gimp_progress_start (progress, cancellable, "%s", undo_desc); if (cancellable) g_signal_connect (progress, "cancel", G_CALLBACK (gimp_gegl_apply_operation_cancel), &cancel); progress_started = TRUE; } } 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++) { gegl_buffer_copy (cache, valid_rects + i, GEGL_ABYSS_NONE, 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); for (i = 0; ! cancel && (i < n_rects); i++) { cairo_rectangle_int_t render_rect; cairo_region_get_rectangle (region, i, &render_rect); 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 while (! cancel && gegl_processor_work (processor, &value)) { gimp_progress_set_value (progress, ((gdouble) done_pixels + value * rect_pixels) / (gdouble) all_pixels); if (cancellable) while (! cancel && g_main_context_pending (NULL)) g_main_context_iteration (NULL, FALSE); } 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); } else { if (progress) { while (! cancel && gegl_processor_work (processor, &value)) { gimp_progress_set_value (progress, value); if (cancellable) while (! cancel && g_main_context_pending (NULL)) g_main_context_iteration (NULL, FALSE); } } else { gegl_node_blit (dest_node, 1.0, &rect, NULL, NULL, 0, GEGL_BLIT_DEFAULT); } } if (processor) g_object_unref (processor); g_object_unref (gegl); if (progress_started) { gimp_progress_end (progress); if (cancellable) g_signal_handlers_disconnect_by_func (progress, gimp_gegl_apply_operation_cancel, &cancel); } return ! cancel; }