From 5c1676dfe6d2f3c837a5e074117b45613fd29a72 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:30:19 +0200 Subject: Adding upstream version 2.10.34. Signed-off-by: Daniel Baumann --- app/core/gimpchannel-select.c | 605 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 605 insertions(+) create mode 100644 app/core/gimpchannel-select.c (limited to 'app/core/gimpchannel-select.c') diff --git a/app/core/gimpchannel-select.c b/app/core/gimpchannel-select.c new file mode 100644 index 0000000..b76280e --- /dev/null +++ b/app/core/gimpchannel-select.c @@ -0,0 +1,605 @@ +/* GIMP - The GNU Image Manipulation Program + * Copyright (C) 1995 Spencer Kimball and Peter Mattis + * + * 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 . + */ + +#include "config.h" + +#include + +#include +#include +#include + +#include "libgimpbase/gimpbase.h" +#include "libgimpmath/gimpmath.h" + +#include "core-types.h" + +#include "gegl/gimp-gegl-apply-operation.h" +#include "gegl/gimp-gegl-loops.h" +#include "gegl/gimp-gegl-mask-combine.h" + +#include "gimpchannel.h" +#include "gimpchannel-select.h" +#include "gimpchannel-combine.h" +#include "gimppickable.h" +#include "gimppickable-contiguous-region.h" +#include "gimpscanconvert.h" + +#include "vectors/gimpstroke.h" +#include "vectors/gimpvectors.h" + +#include "gimp-intl.h" + + +/* basic selection functions */ + +void +gimp_channel_select_rectangle (GimpChannel *channel, + gint x, + gint y, + gint w, + gint h, + GimpChannelOps op, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y, + gboolean push_undo) +{ + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + + if (push_undo) + gimp_channel_push_undo (channel, C_("undo-type", "Rectangle Select")); + + /* if feathering for rect, make a new mask with the + * rectangle and feather that with the old mask + */ + if (feather) + { + GimpItem *item = GIMP_ITEM (channel); + GeglBuffer *add_on; + + add_on = gegl_buffer_new (GEGL_RECTANGLE (0, 0, + gimp_item_get_width (item), + gimp_item_get_height (item)), + babl_format ("Y float")); + + gimp_gegl_mask_combine_rect (add_on, GIMP_CHANNEL_OP_REPLACE, x, y, w, h); + + gimp_gegl_apply_feather (add_on, NULL, NULL, add_on, NULL, + feather_radius_x, + feather_radius_y, + TRUE); + + gimp_channel_combine_buffer (channel, add_on, op, 0, 0); + g_object_unref (add_on); + } + else + { + gimp_channel_combine_rect (channel, op, x, y, w, h); + } +} + +void +gimp_channel_select_ellipse (GimpChannel *channel, + gint x, + gint y, + gint w, + gint h, + GimpChannelOps op, + gboolean antialias, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y, + gboolean push_undo) +{ + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + + if (push_undo) + gimp_channel_push_undo (channel, C_("undo-type", "Ellipse Select")); + + /* if feathering for rect, make a new mask with the + * rectangle and feather that with the old mask + */ + if (feather) + { + GimpItem *item = GIMP_ITEM (channel); + GeglBuffer *add_on; + + add_on = gegl_buffer_new (GEGL_RECTANGLE (0, 0, + gimp_item_get_width (item), + gimp_item_get_height (item)), + babl_format ("Y float")); + + gimp_gegl_mask_combine_ellipse (add_on, GIMP_CHANNEL_OP_REPLACE, + x, y, w, h, antialias); + + gimp_gegl_apply_feather (add_on, NULL, NULL, add_on, NULL, + feather_radius_x, + feather_radius_y, + TRUE); + + gimp_channel_combine_buffer (channel, add_on, op, 0, 0); + g_object_unref (add_on); + } + else + { + gimp_channel_combine_ellipse (channel, op, x, y, w, h, antialias); + } +} + +void +gimp_channel_select_round_rect (GimpChannel *channel, + gint x, + gint y, + gint w, + gint h, + gdouble corner_radius_x, + gdouble corner_radius_y, + GimpChannelOps op, + gboolean antialias, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y, + gboolean push_undo) +{ + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + + if (push_undo) + gimp_channel_push_undo (channel, C_("undo-type", "Rounded Rectangle Select")); + + /* if feathering for rect, make a new mask with the + * rectangle and feather that with the old mask + */ + if (feather) + { + GimpItem *item = GIMP_ITEM (channel); + GeglBuffer *add_on; + + add_on = gegl_buffer_new (GEGL_RECTANGLE (0, 0, + gimp_item_get_width (item), + gimp_item_get_height (item)), + babl_format ("Y float")); + + gimp_gegl_mask_combine_ellipse_rect (add_on, GIMP_CHANNEL_OP_REPLACE, + x, y, w, h, + corner_radius_x, corner_radius_y, + antialias); + + gimp_gegl_apply_feather (add_on, NULL, NULL, add_on, NULL, + feather_radius_x, + feather_radius_y, + TRUE); + + gimp_channel_combine_buffer (channel, add_on, op, 0, 0); + g_object_unref (add_on); + } + else + { + gimp_channel_combine_ellipse_rect (channel, op, x, y, w, h, + corner_radius_x, corner_radius_y, + antialias); + } +} + +/* select by GimpScanConvert functions */ + +void +gimp_channel_select_scan_convert (GimpChannel *channel, + const gchar *undo_desc, + GimpScanConvert *scan_convert, + gint offset_x, + gint offset_y, + GimpChannelOps op, + gboolean antialias, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y, + gboolean push_undo) +{ + GimpItem *item; + GeglBuffer *add_on; + + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + g_return_if_fail (undo_desc != NULL); + g_return_if_fail (scan_convert != NULL); + + if (push_undo) + gimp_channel_push_undo (channel, undo_desc); + + item = GIMP_ITEM (channel); + + add_on = gegl_buffer_new (GEGL_RECTANGLE (0, 0, + gimp_item_get_width (item), + gimp_item_get_height (item)), + babl_format ("Y float")); + + gimp_scan_convert_render (scan_convert, add_on, + offset_x, offset_y, antialias); + + if (feather) + gimp_gegl_apply_feather (add_on, NULL, NULL, add_on, NULL, + feather_radius_x, + feather_radius_y, + TRUE); + + gimp_channel_combine_buffer (channel, add_on, op, 0, 0); + g_object_unref (add_on); +} + +void +gimp_channel_select_polygon (GimpChannel *channel, + const gchar *undo_desc, + gint n_points, + const GimpVector2 *points, + GimpChannelOps op, + gboolean antialias, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y, + gboolean push_undo) +{ + GimpScanConvert *scan_convert; + + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + g_return_if_fail (undo_desc != NULL); + + scan_convert = gimp_scan_convert_new (); + + gimp_scan_convert_add_polyline (scan_convert, n_points, points, TRUE); + + gimp_channel_select_scan_convert (channel, undo_desc, scan_convert, 0, 0, + op, antialias, feather, + feather_radius_x, feather_radius_y, + push_undo); + + gimp_scan_convert_free (scan_convert); +} + +void +gimp_channel_select_vectors (GimpChannel *channel, + const gchar *undo_desc, + GimpVectors *vectors, + GimpChannelOps op, + gboolean antialias, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y, + gboolean push_undo) +{ + const GimpBezierDesc *bezier; + + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + g_return_if_fail (undo_desc != NULL); + g_return_if_fail (GIMP_IS_VECTORS (vectors)); + + bezier = gimp_vectors_get_bezier (vectors); + + if (bezier && bezier->num_data > 4) + { + GimpScanConvert *scan_convert; + + scan_convert = gimp_scan_convert_new (); + gimp_scan_convert_add_bezier (scan_convert, bezier); + + gimp_channel_select_scan_convert (channel, undo_desc, scan_convert, 0, 0, + op, antialias, feather, + feather_radius_x, feather_radius_y, + push_undo); + + gimp_scan_convert_free (scan_convert); + } +} + + +/* select by GimpChannel functions */ + +void +gimp_channel_select_buffer (GimpChannel *channel, + const gchar *undo_desc, + GeglBuffer *add_on, + gint offset_x, + gint offset_y, + GimpChannelOps op, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y) +{ + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + g_return_if_fail (undo_desc != NULL); + g_return_if_fail (GEGL_IS_BUFFER (add_on)); + + gimp_channel_push_undo (channel, undo_desc); + + if (feather) + { + GimpItem *item = GIMP_ITEM (channel); + GeglBuffer *add_on2; + + add_on2 = gegl_buffer_new (GEGL_RECTANGLE (0, 0, + gimp_item_get_width (item), + gimp_item_get_height (item)), + babl_format ("Y float")); + + gimp_gegl_mask_combine_buffer (add_on2, add_on, + GIMP_CHANNEL_OP_REPLACE, + offset_x, offset_y); + + gimp_gegl_apply_feather (add_on2, NULL, NULL, add_on2, NULL, + feather_radius_x, + feather_radius_y, + TRUE); + + gimp_channel_combine_buffer (channel, add_on2, op, 0, 0); + g_object_unref (add_on2); + } + else + { + gimp_channel_combine_buffer (channel, add_on, op, offset_x, offset_y); + } +} + +void +gimp_channel_select_channel (GimpChannel *channel, + const gchar *undo_desc, + GimpChannel *add_on, + gint offset_x, + gint offset_y, + GimpChannelOps op, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y) +{ + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + g_return_if_fail (undo_desc != NULL); + g_return_if_fail (GIMP_IS_CHANNEL (add_on)); + + gimp_channel_select_buffer (channel, undo_desc, + gimp_drawable_get_buffer (GIMP_DRAWABLE (add_on)), + offset_x, offset_y, op, + feather, + feather_radius_x, feather_radius_y); +} + +void +gimp_channel_select_alpha (GimpChannel *channel, + GimpDrawable *drawable, + GimpChannelOps op, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y) +{ + GimpItem *item; + GimpChannel *add_on; + gint off_x, off_y; + + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); + + item = GIMP_ITEM (channel); + + if (gimp_drawable_has_alpha (drawable)) + { + add_on = gimp_channel_new_from_alpha (gimp_item_get_image (item), + drawable, NULL, NULL); + } + else + { + /* no alpha is equivalent to completely opaque alpha, + * so simply select the whole layer's extents. --mitch + */ + add_on = gimp_channel_new_mask (gimp_item_get_image (item), + gimp_item_get_width (GIMP_ITEM (drawable)), + gimp_item_get_height (GIMP_ITEM (drawable))); + gimp_channel_all (add_on, FALSE); + } + + gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y); + + gimp_channel_select_channel (channel, C_("undo-type", "Alpha to Selection"), add_on, + off_x, off_y, + op, feather, + feather_radius_x, + feather_radius_y); + g_object_unref (add_on); +} + +void +gimp_channel_select_component (GimpChannel *channel, + GimpChannelType component, + GimpChannelOps op, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y) +{ + GimpItem *item; + GimpChannel *add_on; + const gchar *desc; + gchar *undo_desc; + + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + + item = GIMP_ITEM (channel); + + add_on = gimp_channel_new_from_component (gimp_item_get_image (item), + component, NULL, NULL); + + if (feather) + gimp_channel_feather (add_on, + feather_radius_x, + feather_radius_y, + TRUE, + FALSE /* no undo */); + + gimp_enum_get_value (GIMP_TYPE_CHANNEL_TYPE, component, + NULL, NULL, &desc, NULL); + + undo_desc = g_strdup_printf (C_("undo-type", "%s Channel to Selection"), desc); + + gimp_channel_select_channel (channel, undo_desc, add_on, + 0, 0, op, + FALSE, 0.0, 0.0); + + g_free (undo_desc); + g_object_unref (add_on); +} + +void +gimp_channel_select_fuzzy (GimpChannel *channel, + GimpDrawable *drawable, + gboolean sample_merged, + gint x, + gint y, + gfloat threshold, + gboolean select_transparent, + GimpSelectCriterion select_criterion, + gboolean diagonal_neighbors, + GimpChannelOps op, + gboolean antialias, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y) +{ + GimpPickable *pickable; + GeglBuffer *add_on; + gint add_on_x = 0; + gint add_on_y = 0; + + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); + + if (sample_merged) + pickable = GIMP_PICKABLE (gimp_item_get_image (GIMP_ITEM (drawable))); + else + pickable = GIMP_PICKABLE (drawable); + + add_on = gimp_pickable_contiguous_region_by_seed (pickable, + antialias, + threshold, + select_transparent, + select_criterion, + diagonal_neighbors, + x, y); + + if (! sample_merged) + gimp_item_get_offset (GIMP_ITEM (drawable), &add_on_x, &add_on_y); + + gimp_channel_select_buffer (channel, C_("undo-type", "Fuzzy Select"), + add_on, add_on_x, add_on_y, + op, + feather, + feather_radius_x, + feather_radius_y); + g_object_unref (add_on); +} + +void +gimp_channel_select_by_color (GimpChannel *channel, + GimpDrawable *drawable, + gboolean sample_merged, + const GimpRGB *color, + gfloat threshold, + gboolean select_transparent, + GimpSelectCriterion select_criterion, + GimpChannelOps op, + gboolean antialias, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y) +{ + GimpPickable *pickable; + GeglBuffer *add_on; + gint add_on_x = 0; + gint add_on_y = 0; + + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); + g_return_if_fail (color != NULL); + + if (sample_merged) + pickable = GIMP_PICKABLE (gimp_item_get_image (GIMP_ITEM (drawable))); + else + pickable = GIMP_PICKABLE (drawable); + + add_on = gimp_pickable_contiguous_region_by_color (pickable, + antialias, + threshold, + select_transparent, + select_criterion, + color); + + if (! sample_merged) + gimp_item_get_offset (GIMP_ITEM (drawable), &add_on_x, &add_on_y); + + gimp_channel_select_buffer (channel, C_("undo-type", "Select by Color"), + add_on, add_on_x, add_on_y, + op, + feather, + feather_radius_x, + feather_radius_y); + g_object_unref (add_on); +} + +void +gimp_channel_select_by_index (GimpChannel *channel, + GimpDrawable *drawable, + gint index, + GimpChannelOps op, + gboolean feather, + gdouble feather_radius_x, + gdouble feather_radius_y) +{ + GeglBuffer *add_on; + gint add_on_x = 0; + gint add_on_y = 0; + + g_return_if_fail (GIMP_IS_CHANNEL (channel)); + g_return_if_fail (gimp_item_is_attached (GIMP_ITEM (channel))); + g_return_if_fail (GIMP_IS_DRAWABLE (drawable)); + g_return_if_fail (gimp_drawable_is_indexed (drawable)); + + add_on = gegl_buffer_new (GEGL_RECTANGLE (0, 0, + gimp_item_get_width (GIMP_ITEM (drawable)), + gimp_item_get_height (GIMP_ITEM (drawable))), + babl_format ("Y float")); + + gimp_gegl_index_to_mask (gimp_drawable_get_buffer (drawable), NULL, + gimp_drawable_get_format_without_alpha (drawable), + add_on, NULL, + index); + + gimp_item_get_offset (GIMP_ITEM (drawable), &add_on_x, &add_on_y); + + gimp_channel_select_buffer (channel, C_("undo-type", "Select by Indexed Color"), + add_on, add_on_x, add_on_y, + op, + feather, + feather_radius_x, + feather_radius_y); + g_object_unref (add_on); +} -- cgit v1.2.3