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); }
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) { 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, node, dest_buffer, dest_rect); g_object_unref (node); }
void gimp_gegl_apply_color_reduction (GeglBuffer *src_buffer, GimpProgress *progress, const gchar *undo_desc, GeglBuffer *dest_buffer, gint bits, gint dither_type) { GeglNode *node; g_return_if_fail (GEGL_IS_BUFFER (src_buffer)); g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress)); g_return_if_fail (GEGL_IS_BUFFER (dest_buffer)); node = gegl_node_new_child (NULL, "operation", "gegl:color-reduction", "red-bits", bits, "green-bits", bits, "blue-bits", bits, "alpha-bits", bits, "dither-strategy", dither_type, 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, "operation", "gegl:transform", "sampler", interpolation_type, 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); }
/** * mypaint_gegl_tiled_surface_set_buffer: * @buffer: (transfer full): The buffer which shall back this surface. * */ void mypaint_gegl_tiled_surface_set_buffer(MyPaintGeglTiledSurface *self, GeglBuffer *buffer) { if (buffer && self->buffer == buffer) { return; } if (self->buffer) { g_object_unref(self->buffer); } if (buffer) { g_return_if_fail(GEGL_IS_BUFFER(buffer)); g_object_ref(buffer); self->buffer = buffer; } else { // Using GeglBuffer with aligned tiles for zero-copy access self->buffer = GEGL_BUFFER(g_object_new(GEGL_TYPE_BUFFER, "x", self->extent_rect.x, "y", self->extent_rect.y, "width", self->extent_rect.width, "height", self->extent_rect.height, "format", self->format, "tile-width", self->parent.tile_size, "tile-height", self->parent.tile_size, NULL)); } g_assert(GEGL_IS_BUFFER(self->buffer)); self->parent.threadsafe_tile_requests = buffer_is_native(self); }
static void set_buffer (GeglSampler *self, GeglBuffer *buffer) { if (self->buffer != buffer) { if (GEGL_IS_BUFFER (self->buffer)) { g_signal_handlers_disconnect_by_func (self->buffer, G_CALLBACK (buffer_contents_changed), self); g_object_remove_weak_pointer ((GObject*) self->buffer, (void**) &self->buffer); } if (GEGL_IS_BUFFER (buffer)) { self->buffer = buffer; g_object_add_weak_pointer ((GObject*) self->buffer, (void**) &self->buffer); g_signal_connect (buffer, "changed", G_CALLBACK (buffer_contents_changed), self); } else self->buffer = NULL; buffer_contents_changed (buffer, NULL, self); } }
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, "operation", "gegl:scale-ratio", "origin-x", 0.0, "origin-y", 0.0, "sampler", interpolation_type, "x", x, "y", y, NULL); gimp_gegl_apply_operation (src_buffer, progress, undo_desc, node, dest_buffer, NULL); g_object_unref (node); }
GimpUndo * gimp_image_undo_push_drawable (GimpImage *image, const gchar *undo_desc, GimpDrawable *drawable, GeglBuffer *buffer, gint x, gint y) { GimpItem *item; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL); item = GIMP_ITEM (drawable); g_return_val_if_fail (gimp_item_is_attached (item), NULL); return gimp_image_undo_push (image, GIMP_TYPE_DRAWABLE_UNDO, GIMP_UNDO_DRAWABLE, undo_desc, GIMP_DIRTY_ITEM | GIMP_DIRTY_DRAWABLE, "item", item, "buffer", buffer, "x", x, "y", y, NULL); }
/** * gimp_layer_new_from_gegl_buffer: * @buffer: The buffer to make the new layer from. * @dest_image: The image the new layer will be added to. * @format: The #Babl format of the new layer. * @name: The new layer's name. * @opacity: The new layer's opacity. * @mode: The new layer's mode. * * Copies %buffer to a layer taking into consideration the * possibility of transforming the contents to meet the requirements * of the target image type * * Return value: The new layer. **/ GimpLayer * gimp_layer_new_from_gegl_buffer (GeglBuffer *buffer, GimpImage *dest_image, const Babl *format, const gchar *name, gdouble opacity, GimpLayerModeEffects mode, GimpColorProfile *buffer_profile) { GimpLayer *layer; g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL); g_return_val_if_fail (GIMP_IS_IMAGE (dest_image), NULL); g_return_val_if_fail (format != NULL, NULL); g_return_val_if_fail (buffer_profile == NULL || GIMP_IS_COLOR_PROFILE (buffer_profile), NULL); /* do *not* use the buffer's format because this function gets * buffers of any format passed, and converts them */ layer = gimp_layer_new (dest_image, gegl_buffer_get_width (buffer), gegl_buffer_get_height (buffer), format, name, opacity, mode); gimp_layer_new_convert_buffer (layer, buffer, buffer_profile, NULL); return layer; }
gboolean gimp_gegl_mask_is_empty (GeglBuffer *buffer) { GeglBufferIterator *iter; g_return_val_if_fail (GEGL_IS_BUFFER (buffer), FALSE); iter = gegl_buffer_iterator_new (buffer, NULL, 0, babl_format ("Y float"), GEGL_BUFFER_READ, GEGL_ABYSS_NONE); while (gegl_buffer_iterator_next (iter)) { gfloat *data = iter->data[0]; gint i; for (i = 0; i < iter->length; i++) { if (data[i]) { gegl_buffer_iterator_stop (iter); return FALSE; } } } return TRUE; }
void gimp_create_image_from_buffer (Gimp *gimp, GeglBuffer *buffer) { GimpImage *image; GimpLayer *layer; const Babl *format; g_return_if_fail (GIMP_IS_GIMP (gimp)); g_return_if_fail (GEGL_IS_BUFFER (buffer)); format = gegl_buffer_get_format (buffer); image = gimp_create_image (gimp, gegl_buffer_get_width (buffer), gegl_buffer_get_height (buffer), gimp_babl_format_get_base_type (format), gimp_babl_format_get_precision (format), FALSE); layer = gimp_layer_new_from_buffer (buffer, image, format, "Debug Image", GIMP_OPACITY_OPAQUE, GIMP_NORMAL_MODE); gimp_image_add_layer (image, layer, NULL, -1, FALSE); gimp_create_display (gimp, image, GIMP_UNIT_PIXEL, 1.0); }
void gimp_channel_combine_buffer (GimpChannel *mask, GeglBuffer *add_on_buffer, GimpChannelOps op, gint off_x, gint off_y) { GeglBuffer *buffer; gint x, y, w, h; g_return_if_fail (GIMP_IS_CHANNEL (mask)); g_return_if_fail (GEGL_IS_BUFFER (add_on_buffer)); buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)); if (! gimp_gegl_mask_combine_buffer (buffer, add_on_buffer, op, off_x, off_y)) return; gimp_rectangle_intersect (off_x, off_y, gegl_buffer_get_width (add_on_buffer), gegl_buffer_get_height (add_on_buffer), 0, 0, gimp_item_get_width (GIMP_ITEM (mask)), gimp_item_get_height (GIMP_ITEM (mask)), &x, &y, &w, &h); mask->bounds_known = FALSE; gimp_drawable_update (GIMP_DRAWABLE (mask), x, y, w, h); }
void gegl_render_op (GeglBuffer *source_buffer, GeglBuffer *target_buffer, const gchar *first_property_name, ...) { va_list var_args; g_return_if_fail (GEGL_IS_BUFFER (source_buffer)); g_return_if_fail (GEGL_IS_BUFFER (target_buffer)); va_start (var_args, first_property_name); gegl_render_op_valist (source_buffer, target_buffer, first_property_name, var_args); va_end (var_args); }
gboolean gimp_gegl_mask_is_empty (GeglBuffer *buffer) { GeglBufferIterator *iter; const Babl *format; gint bpp; g_return_val_if_fail (GEGL_IS_BUFFER (buffer), FALSE); format = gegl_buffer_get_format (buffer); bpp = babl_format_get_bytes_per_pixel (format); iter = gegl_buffer_iterator_new (buffer, NULL, 0, format, GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 1); while (gegl_buffer_iterator_next (iter)) { if (! gegl_memeq_zero (iter->items[0].data, bpp * iter->length)) { gegl_buffer_iterator_stop (iter); return FALSE; } } return TRUE; }
void gimp_channel_combine_buffer (GimpChannel *mask, GeglBuffer *add_on_buffer, GimpChannelOps op, gint off_x, gint off_y) { GimpChannelCombineData data; g_return_if_fail (GIMP_IS_CHANNEL (mask)); g_return_if_fail (GEGL_IS_BUFFER (add_on_buffer)); if (gimp_channel_combine_start (mask, op, GEGL_RECTANGLE ( off_x, off_y, gegl_buffer_get_width (add_on_buffer), gegl_buffer_get_height (add_on_buffer)), FALSE, FALSE, &data)) { GeglBuffer *buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (mask)); gimp_gegl_mask_combine_buffer (buffer, add_on_buffer, op, off_x, off_y); } gimp_channel_combine_end (mask, &data); }
void gimp_applicator_set_mask_buffer (GimpApplicator *applicator, GeglBuffer *mask_buffer) { g_return_if_fail (GIMP_IS_APPLICATOR (applicator)); g_return_if_fail (mask_buffer == NULL || GEGL_IS_BUFFER (mask_buffer)); if (applicator->mask_buffer == mask_buffer) return; gegl_node_set (applicator->mask_node, "buffer", mask_buffer, NULL); if (mask_buffer) { gegl_node_connect_to (applicator->mask_offset_node, "output", applicator->mode_node, "aux2"); } else { gegl_node_disconnect (applicator->mode_node, "aux2"); } applicator->mask_buffer = mask_buffer; }
GimpTransformResize gimp_drawable_transform_get_effective_clip (GimpDrawable *drawable, GeglBuffer *orig_buffer, GimpTransformResize clip_result) { g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), clip_result); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), clip_result); g_return_val_if_fail (orig_buffer == NULL || GEGL_IS_BUFFER (orig_buffer), clip_result); /* Always clip unfloated buffers since they must keep their size */ if (GIMP_IS_CHANNEL (drawable)) { if (orig_buffer) { if (! babl_format_has_alpha (gegl_buffer_get_format (orig_buffer))) clip_result = GIMP_TRANSFORM_RESIZE_CLIP; } else { GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable)); if (gimp_channel_is_empty (gimp_image_get_mask (image))) clip_result = GIMP_TRANSFORM_RESIZE_CLIP; } } return clip_result; }
GimpBuffer * gimp_buffer_new (GeglBuffer *buffer, const gchar *name, gint offset_x, gint offset_y, gboolean copy_pixels) { GimpBuffer *gimp_buffer; g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL); g_return_val_if_fail (name != NULL, NULL); gimp_buffer = g_object_new (GIMP_TYPE_BUFFER, "name", name, NULL); if (copy_pixels) gimp_buffer->buffer = gegl_buffer_dup (buffer); else gimp_buffer->buffer = g_object_ref (buffer); gimp_buffer->offset_x = offset_x; gimp_buffer->offset_y = offset_y; return gimp_buffer; }
GeglNode * gimp_gegl_add_buffer_source (GeglNode *parent, GeglBuffer *buffer, gint offset_x, gint offset_y) { GeglNode *buffer_source; g_return_val_if_fail (GEGL_IS_NODE (parent), NULL); g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL); buffer_source = gegl_node_new_child (parent, "operation", "gegl:buffer-source", "buffer", buffer, NULL); if (offset_x != 0 || offset_y != 0) { GeglNode *translate = gegl_node_new_child (parent, "operation", "gegl:translate", "x", (gdouble) offset_x, "y", (gdouble) offset_y, NULL); gegl_node_connect_to (buffer_source, "output", translate, "input"); buffer_source = translate; } return buffer_source; }
GimpDrawable * gimp_drawable_transform_paste (GimpDrawable *drawable, GeglBuffer *buffer, GimpColorProfile *buffer_profile, gint offset_x, gint offset_y, gboolean new_layer) { GimpImage *image; GimpLayer *layer = NULL; const gchar *undo_desc = NULL; g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (gimp_item_is_attached (GIMP_ITEM (drawable)), NULL); g_return_val_if_fail (GEGL_IS_BUFFER (buffer), NULL); g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (buffer_profile), NULL); image = gimp_item_get_image (GIMP_ITEM (drawable)); if (GIMP_IS_LAYER (drawable)) undo_desc = C_("undo-type", "Transform Layer"); else if (GIMP_IS_CHANNEL (drawable)) undo_desc = C_("undo-type", "Transform Channel"); else return NULL; gimp_image_undo_group_start (image, GIMP_UNDO_GROUP_EDIT_PASTE, undo_desc); if (new_layer) { layer = gimp_layer_new_from_gegl_buffer (buffer, image, gimp_drawable_get_format_with_alpha (drawable), _("Transformation"), GIMP_OPACITY_OPAQUE, gimp_image_get_default_new_layer_mode (image), buffer_profile); gimp_item_set_offset (GIMP_ITEM (layer), offset_x, offset_y); floating_sel_attach (layer, drawable); drawable = GIMP_DRAWABLE (layer); } else { gimp_drawable_set_buffer_full (drawable, TRUE, NULL, buffer, offset_x, offset_y, TRUE); } gimp_image_undo_group_end (image); return drawable; }
gboolean gegl_buffer_set_abyss (GeglBuffer *buffer, const GeglRectangle *abyss) { g_return_val_if_fail(GEGL_IS_BUFFER(buffer), FALSE); buffer->abyss = *abyss; return TRUE; }
void gimp_gegl_apply_flatten (GeglBuffer *src_buffer, GimpProgress *progress, const gchar *undo_desc, GeglBuffer *dest_buffer, const GimpRGB *background) { GeglNode *node; g_return_if_fail (GEGL_IS_BUFFER (src_buffer)); g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress)); g_return_if_fail (GEGL_IS_BUFFER (dest_buffer)); g_return_if_fail (background != NULL); node = gimp_gegl_create_flatten_node (background); gimp_gegl_apply_operation (src_buffer, progress, undo_desc, node, dest_buffer, NULL); g_object_unref (node); }
void gimp_gegl_apply_invert_linear (GeglBuffer *src_buffer, GimpProgress *progress, const gchar *undo_desc, GeglBuffer *dest_buffer) { GeglNode *node; g_return_if_fail (GEGL_IS_BUFFER (src_buffer)); g_return_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress)); g_return_if_fail (GEGL_IS_BUFFER (dest_buffer)); node = gegl_node_new_child (NULL, "operation", "gegl:invert-linear", NULL); gimp_gegl_apply_operation (src_buffer, progress, undo_desc, node, dest_buffer, NULL); g_object_unref (node); }
void gimp_gegl_apply_feather (GeglBuffer *src_buffer, GimpProgress *progress, const gchar *undo_desc, GeglBuffer *dest_buffer, gdouble radius_x, gdouble radius_y) { 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, dest_buffer, radius_x / 3.5, radius_y / 3.5); }
void gegl_operation_context_set_object (GeglOperationContext *context, const gchar *padname, GObject *data) { g_return_if_fail (!data || GEGL_IS_BUFFER (data)); /* Make it simple, just add an extra ref and then take the object */ if (data) g_object_ref (data); gegl_operation_context_take_object (context, padname, data); }
void gegl_apply_op (GeglBuffer *buffer, const gchar *first_property_name, ...) { va_list var_args; g_return_if_fail (GEGL_IS_BUFFER (buffer)); va_start (var_args, first_property_name); gegl_apply_op_valist (buffer, first_property_name, var_args); va_end (var_args); }
void gegl_operation_context_take_object (GeglOperationContext *context, const gchar *padname, GObject *data) { GValue *storage; g_return_if_fail (context != NULL); g_return_if_fail (!data || GEGL_IS_BUFFER (data)); storage = gegl_operation_context_add_value (context, padname); g_value_take_object (storage, data); }
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 gegl_apply_op_valist (GeglBuffer *buffer, const gchar *first_property_name, va_list var_args) { GeglBuffer *tempbuf = NULL; GeglNode *node; GeglNode *source; GeglNode *sink; g_return_if_fail (GEGL_IS_BUFFER (buffer)); g_object_ref (buffer); source = gegl_node_new_child (NULL, "operation", "gegl:buffer-source", "buffer", buffer, NULL); node = gegl_node_new_child (NULL, "operation", first_property_name, NULL); if (!GEGL_IS_OPERATION_POINT_FILTER (node->operation)) { tempbuf = gegl_buffer_new (gegl_buffer_get_extent (buffer), gegl_buffer_get_format (buffer)); sink = gegl_node_new_child (NULL, "operation", "gegl:write-buffer", "buffer", tempbuf, NULL); } else { sink = gegl_node_new_child (NULL, "operation", "gegl:write-buffer", "buffer", buffer, NULL); } gegl_node_link_many (source, node, sink, NULL); gegl_node_set_props (node, var_args); gegl_node_process (sink); g_object_unref (source); g_object_unref (node); g_object_unref (sink); if (tempbuf) { gegl_buffer_copy (tempbuf, NULL, buffer, NULL); g_object_unref (tempbuf); } g_object_unref (buffer); }