summaryrefslogtreecommitdiffstats
path: root/plug-ins/common/decompose.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:30:19 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 18:30:19 +0000
commit5c1676dfe6d2f3c837a5e074117b45613fd29a72 (patch)
treecbffb45144febf451e54061db2b21395faf94bfe /plug-ins/common/decompose.c
parentInitial commit. (diff)
downloadgimp-5c1676dfe6d2f3c837a5e074117b45613fd29a72.tar.xz
gimp-5c1676dfe6d2f3c837a5e074117b45613fd29a72.zip
Adding upstream version 2.10.34.upstream/2.10.34upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'plug-ins/common/decompose.c')
-rw-r--r--plug-ins/common/decompose.c973
1 files changed, 973 insertions, 0 deletions
diff --git a/plug-ins/common/decompose.c b/plug-ins/common/decompose.c
new file mode 100644
index 0000000..b96c317
--- /dev/null
+++ b/plug-ins/common/decompose.c
@@ -0,0 +1,973 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * Decompose plug-in (C) 1997 Peter Kirchgessner
+ * e-mail: peter@kirchgessner.net, WWW: http://www.kirchgessner.net
+ *
+ * Copyright 2013 Martijn van Beers <mail_dev@martijn.at>
+ * Copyright 2013 Téo Mazars <teo.mazars@ensimag.fr>
+ *
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+
+/* Lab colorspace support originally written by Alexey Dyachenko,
+ * merged into the officical plug-in by Sven Neumann.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "libgimp/stdplugins-intl.h"
+
+#define PLUG_IN_PROC "plug-in-decompose"
+#define PLUG_IN_PROC_REG "plug-in-decompose-registered"
+#define PLUG_IN_BINARY "decompose"
+#define PLUG_IN_ROLE "gimp-decompose"
+
+
+/* Description of a component */
+typedef struct
+{
+ const gchar *babl_name; /* channel's babl_component name */
+ const gchar *channel_name; /* name of channel to extract */
+
+ const gdouble range_min; /* min and max */
+ const gdouble range_max;
+ const gboolean perceptual_channel; /* "correct" the channel in Y' space */
+
+} Component;
+
+
+/* Maximum number of images/layers generated by an extraction */
+#define MAX_EXTRACT_IMAGES 4
+
+/* Description of an extraction */
+typedef struct
+{
+ const gchar *type; /* What to extract */
+ const gchar *model; /* the babl_model string to use */
+ const gboolean dialog; /* Set to TRUE if you want
+ * this extract function in the dialog */
+ const gint num_images; /* Number of images to create */
+
+ const gboolean clamp; /* clamping values in [0.0, 1.0] */
+
+ /* the babl_component names of the channels */
+ const Component component[MAX_EXTRACT_IMAGES];
+
+} Extract;
+
+typedef struct
+{
+ gchar extract_type[32];
+ gboolean as_layers;
+ gboolean use_registration;
+} DecomposeVals;
+
+
+/* Declare local functions
+ */
+static void query (void);
+static void run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals);
+static gint32 decompose (gint32 image_id,
+ gint32 drawable_ID,
+ const gchar *extract_type,
+ gint32 *image_ID_dst,
+ gint32 *num_layers,
+ gint32 *layer_ID_dst);
+static gint32 create_new_image (const gchar *filename,
+ const gchar *layername,
+ guint width,
+ guint height,
+ GimpImageBaseType type,
+ GimpPrecision precision,
+ gdouble xres,
+ gdouble yres,
+ gint32 *layer_ID);
+static gint32 create_new_layer (gint32 image_ID,
+ gint position,
+ const gchar *layername,
+ guint width,
+ guint height,
+ GimpImageBaseType type);
+static void transfer_registration_color (GeglBuffer *src,
+ GeglBuffer **dst,
+ gint count);
+static void cpn_affine_transform_clamp (GeglBuffer *buffer,
+ gdouble min,
+ gdouble max,
+ gboolean clamp);
+static void copy_n_components (GeglBuffer *src,
+ GeglBuffer **dst,
+ Extract ext);
+static void copy_one_component (GeglBuffer *src,
+ GeglBuffer *dst,
+ const char *model,
+ const Component component,
+ gboolean clamp);
+static gboolean decompose_dialog (void);
+static gchar * generate_filename (guint32 image_ID,
+ guint colorspace,
+ guint channel);
+
+
+#define CPN_RGBA_R { "R", N_("red"), 0.0, 1.0, FALSE }
+#define CPN_RGBA_G { "G", N_("green"), 0.0, 1.0, FALSE }
+#define CPN_RGBA_B { "B", N_("blue"), 0.0, 1.0, FALSE }
+#define CPN_RGBA_A { "A", N_("alpha"), 0.0, 1.0, TRUE }
+
+#define CPN_HSV_H { "hue", N_("hue"), 0.0, 1.0, TRUE }
+#define CPN_HSV_S { "saturation", N_("saturation"), 0.0, 1.0, TRUE }
+#define CPN_HSV_V { "value", N_("value"), 0.0, 1.0, TRUE }
+
+#define CPN_HSL_H { "hue", N_("hue"), 0.0, 1.0, TRUE }
+#define CPN_HSL_S { "saturation", N_("saturation"), 0.0, 1.0, TRUE }
+#define CPN_HSL_L { "lightness", N_("lightness"), 0.0, 1.0, TRUE }
+
+#define CPN_CMYK_C { "Cyan", N_("cyan"), 0.0, 1.0, TRUE }
+#define CPN_CMYK_M { "Magenta", N_("magenta"), 0.0, 1.0, TRUE }
+#define CPN_CMYK_Y { "Yellow", N_("yellow"), 0.0, 1.0, TRUE }
+#define CPN_CMYK_K { "Key", N_("black"), 0.0, 1.0, TRUE }
+
+#define CPN_LAB_L { "CIE L", N_("L"), 0.0, 100.0, TRUE }
+#define CPN_LAB_A { "CIE a", N_("A"), -127.5, 127.5, TRUE }
+#define CPN_LAB_B { "CIE b", N_("B"), -127.5, 127.5, TRUE }
+
+#define CPN_LCH_L { "CIE L", N_("L"), 0.0, 100.0, TRUE }
+#define CPN_LCH_C { "CIE C(ab)", N_("C"), 0.0, 200.0, TRUE }
+#define CPN_LCH_H { "CIE H(ab)", N_("H"), 0.0, 360.0, TRUE }
+
+#define CPN_YCBCR_Y { "Y'", N_("luma-y470"), 0.0, 1.0, TRUE }
+#define CPN_YCBCR_CB { "Cb", N_("blueness-cb470"), -0.5, 0.5, TRUE }
+#define CPN_YCBCR_CR { "Cr", N_("redness-cr470"), -0.5, 0.5, TRUE }
+
+#define CPN_YCBCR709_Y { "Y'", N_("luma-y709"), 0.0, 1.0, TRUE }
+#define CPN_YCBCR709_CB { "Cb", N_("blueness-cb709"), -0.5, 0.5, TRUE }
+#define CPN_YCBCR709_CR { "Cr", N_("redness-cr709"), -0.5, 0.5, TRUE }
+
+
+static const Extract extract[] =
+{
+ { N_("RGB"), "RGB", TRUE, 3, FALSE, { CPN_RGBA_R, CPN_RGBA_G, CPN_RGBA_B } },
+ { N_("RGBA"), "RGBA", TRUE, 4, FALSE, { CPN_RGBA_R, CPN_RGBA_G, CPN_RGBA_B, CPN_RGBA_A } },
+
+ { N_("Red"), "RGB", FALSE, 1, FALSE, { CPN_RGBA_R } },
+ { N_("Green"), "RGB", FALSE, 1, FALSE, { CPN_RGBA_G } },
+ { N_("Blue"), "RGB", FALSE, 1, FALSE, { CPN_RGBA_B } },
+ { N_("Alpha"), "RGBA", TRUE , 1, FALSE, { CPN_RGBA_A } },
+
+ { N_("HSV"), "HSV", TRUE, 3, FALSE, { CPN_HSV_H, CPN_HSV_S, CPN_HSV_V } },
+ { N_("Hue"), "HSV", FALSE, 1, FALSE, { CPN_HSV_H } },
+ { N_("Saturation"), "HSV", FALSE, 1, FALSE, { CPN_HSV_S } },
+ { N_("Value"), "HSV", FALSE, 1, FALSE, { CPN_HSV_V } },
+
+ { N_("HSL"), "HSL", TRUE, 3, FALSE, { CPN_HSL_H, CPN_HSL_S, CPN_HSL_L } },
+ { N_("Hue (HSL)"), "HSL", FALSE, 1, FALSE, { CPN_HSL_H } },
+ { N_("Saturation (HSL)"), "HSL", FALSE, 1, FALSE, { CPN_HSL_S } },
+ { N_("Lightness"), "HSL", FALSE, 1, FALSE, { CPN_HSL_L } },
+
+ { N_("CMYK"), "CMYK", TRUE, 4, FALSE, { CPN_CMYK_C, CPN_CMYK_M, CPN_CMYK_Y, CPN_CMYK_K } },
+ { N_("Cyan"), "CMYK", FALSE, 1, FALSE, { CPN_CMYK_C } },
+ { N_("Magenta"), "CMYK", FALSE, 1, FALSE, { CPN_CMYK_M } },
+ { N_("Yellow"), "CMYK", FALSE, 1, FALSE, { CPN_CMYK_Y } },
+ { N_("Black"), "CMYK", FALSE, 1, FALSE, { CPN_CMYK_K } },
+
+ { N_("LAB"), "CIE Lab", TRUE, 3, FALSE, { CPN_LAB_L, CPN_LAB_A, CPN_LAB_B } },
+
+ { N_("LCH"), "CIE LCH(ab)", TRUE, 3, FALSE, { CPN_LCH_L, CPN_LCH_C, CPN_LCH_H } },
+
+ { N_("YCbCr_ITU_R470"), "Y'CbCr", TRUE, 3, FALSE, { CPN_YCBCR_Y, CPN_YCBCR_CB, CPN_YCBCR_CR} },
+ { N_("YCbCr_ITU_R470_256"), "Y'CbCr", TRUE, 3, TRUE, { CPN_YCBCR_Y, CPN_YCBCR_CB, CPN_YCBCR_CR} },
+
+ { N_("YCbCr_ITU_R709"), "Y'CbCr709", TRUE, 3, FALSE, { CPN_YCBCR709_Y, CPN_YCBCR709_CB, CPN_YCBCR709_CR} },
+ { N_("YCbCr_ITU_R709_256"), "Y'CbCr709", TRUE, 3, TRUE, { CPN_YCBCR709_Y, CPN_YCBCR709_CB, CPN_YCBCR709_CR} }
+};
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+ NULL, /* init_proc */
+ NULL, /* quit_proc */
+ query, /* query_proc */
+ run, /* run_proc */
+};
+
+static DecomposeVals decovals =
+{
+ "rgb", /* Decompose type */
+ TRUE, /* Decompose to Layers */
+ FALSE /* use registration color */
+};
+
+
+MAIN ()
+
+
+static void
+query (void)
+{
+ static GimpParamDef args[] =
+ {
+ { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
+ { GIMP_PDB_IMAGE, "image", "Input image (unused)" },
+ { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
+ { GIMP_PDB_STRING, "decompose-type", NULL },
+ { GIMP_PDB_INT32, "layers-mode", "Create channels as layers in a single image" }
+ };
+ static const GimpParamDef return_vals[] =
+ {
+ { GIMP_PDB_IMAGE, "new-image", "Output gray image" },
+ { GIMP_PDB_IMAGE, "new-image", "Output gray image (N/A for single channel extract)" },
+ { GIMP_PDB_IMAGE, "new-image", "Output gray image (N/A for single channel extract)" },
+ { GIMP_PDB_IMAGE, "new-image", "Output gray image (N/A for single channel extract)" }
+ };
+
+ GString *type_desc;
+ gint i;
+
+ type_desc = g_string_new ("What to decompose: ");
+ g_string_append_c (type_desc, '"');
+ g_string_append (type_desc, extract[0].type);
+ g_string_append_c (type_desc, '"');
+
+ for (i = 1; i < G_N_ELEMENTS (extract); i++)
+ {
+ g_string_append (type_desc, ", ");
+ g_string_append_c (type_desc, '"');
+ g_string_append (type_desc, extract[i].type);
+ g_string_append_c (type_desc, '"');
+ }
+
+ args[3].description = type_desc->str;
+
+ gimp_install_procedure (PLUG_IN_PROC,
+ N_("Decompose an image into separate colorspace components"),
+ "This function creates new gray images with "
+ "different channel information in each of them",
+ "Peter Kirchgessner",
+ "Peter Kirchgessner",
+ "1997",
+ N_("_Decompose..."),
+ "RGB*",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (args),
+ G_N_ELEMENTS (return_vals),
+ args, return_vals);
+
+ gimp_install_procedure (PLUG_IN_PROC_REG,
+ N_("Decompose an image into separate colorspace components"),
+ "This function creates new gray images with "
+ "different channel information in each of them. "
+ "Pixels in the foreground color will appear black "
+ "in all output images. This can be used for "
+ "things like crop marks that have to show up on "
+ "all channels.",
+ "Peter Kirchgessner",
+ "Peter Kirchgessner, Clarence Risher",
+ "1997",
+ N_("_Decompose..."),
+ "RGB*",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (args),
+ G_N_ELEMENTS (return_vals),
+ args, return_vals);
+
+ gimp_plugin_menu_register (PLUG_IN_PROC_REG, "<Image>/Colors/Components");
+
+ g_string_free (type_desc, TRUE);
+}
+
+static void
+run (const gchar *name,
+ gint nparams,
+ const GimpParam *param,
+ gint *nreturn_vals,
+ GimpParam **return_vals)
+{
+ static GimpParam values[MAX_EXTRACT_IMAGES + 1];
+ GimpPDBStatusType status = GIMP_PDB_SUCCESS;
+ GimpRunMode run_mode;
+ gint32 num_images;
+ gint32 image_ID_extract[MAX_EXTRACT_IMAGES];
+ gint32 layer_ID_extract[MAX_EXTRACT_IMAGES];
+ gint j;
+ gint32 layer;
+ gint32 num_layers;
+ gint32 image_ID;
+
+ INIT_I18N ();
+ gegl_init (NULL, NULL);
+
+ run_mode = param[0].data.d_int32;
+ image_ID = param[1].data.d_image;
+ layer = param[2].data.d_drawable;
+
+ *nreturn_vals = MAX_EXTRACT_IMAGES + 1;
+ *return_vals = values;
+
+ values[0].type = GIMP_PDB_STATUS;
+ values[0].data.d_status = status;
+
+ for (j = 0; j < MAX_EXTRACT_IMAGES; j++)
+ {
+ values[j+1].type = GIMP_PDB_IMAGE;
+ values[j+1].data.d_int32 = -1;
+ }
+
+ switch (run_mode)
+ {
+ case GIMP_RUN_INTERACTIVE:
+ /* Possibly retrieve data */
+ gimp_get_data (PLUG_IN_PROC, &decovals);
+
+ /* First acquire information with a dialog */
+ if (! decompose_dialog ())
+ return;
+ break;
+
+ case GIMP_RUN_NONINTERACTIVE:
+ /* Make sure all the arguments are there! */
+ if (nparams != 4 && nparams != 5 && nparams != 6)
+ {
+ status = GIMP_PDB_CALLING_ERROR;
+ }
+ else
+ {
+ strncpy (decovals.extract_type, param[3].data.d_string,
+ sizeof (decovals.extract_type));
+ decovals.extract_type[sizeof (decovals.extract_type) - 1] = '\0';
+
+ decovals.as_layers = nparams > 4 ? param[4].data.d_int32 : FALSE;
+ decovals.use_registration = (strcmp (name, PLUG_IN_PROC_REG) == 0);
+ }
+ break;
+
+ case GIMP_RUN_WITH_LAST_VALS:
+ /* Possibly retrieve data */
+ gimp_get_data (PLUG_IN_PROC, &decovals);
+ break;
+
+ default:
+ break;
+ }
+
+ if (status == GIMP_PDB_SUCCESS)
+ {
+ gimp_progress_init (_("Decomposing"));
+
+ num_images = decompose (image_ID, layer,
+ decovals.extract_type,
+ image_ID_extract,
+ &num_layers,
+ layer_ID_extract);
+
+ if (num_images <= 0)
+ {
+ status = GIMP_PDB_EXECUTION_ERROR;
+ }
+ else
+ {
+ /* create decompose-data parasite */
+ GString *data = g_string_new ("");
+
+ g_string_printf (data, "source=%d type=%s ",
+ layer, decovals.extract_type);
+
+ for (j = 0; j < num_layers; j++)
+ g_string_append_printf (data, "%d ", layer_ID_extract[j]);
+
+ for (j = 0; j < num_images; j++)
+ {
+ GimpParasite *parasite;
+
+ values[j+1].data.d_int32 = image_ID_extract[j];
+
+ gimp_image_undo_enable (image_ID_extract[j]);
+ gimp_image_clean_all (image_ID_extract[j]);
+
+ parasite = gimp_parasite_new ("decompose-data",
+ 0, data->len + 1, data->str);
+ gimp_image_attach_parasite (image_ID_extract[j], parasite);
+ gimp_parasite_free (parasite);
+
+ if (run_mode != GIMP_RUN_NONINTERACTIVE)
+ gimp_display_new (image_ID_extract[j]);
+ }
+
+ /* Store data */
+ if (run_mode == GIMP_RUN_INTERACTIVE)
+ gimp_set_data (PLUG_IN_PROC, &decovals, sizeof (DecomposeVals));
+ }
+
+ gimp_progress_end ();
+ }
+
+ values[0].data.d_status = status;
+}
+
+
+/* Decompose an image. It returns the number of new (gray) images.
+ * The image IDs for the new images are returned in image_ID_dst.
+ * On failure, -1 is returned.
+ */
+static gint32
+decompose (gint32 image_ID,
+ gint32 drawable_ID,
+ const gchar *extract_type,
+ gint32 *image_ID_dst,
+ gint32 *nlayers,
+ gint32 *layer_ID_dst)
+{
+ const gchar *layername;
+ gint j, extract_idx;
+ gint height, width, num_layers;
+ GeglBuffer *src_buffer;
+ GeglBuffer *dst_buffer[MAX_EXTRACT_IMAGES];
+ GimpPrecision precision;
+ gboolean requirements = FALSE;
+ gboolean decomp_has_alpha = FALSE;
+
+ extract_idx = -1; /* Search extract type */
+ for (j = 0; j < G_N_ELEMENTS (extract); j++)
+ {
+ if (g_ascii_strcasecmp (extract_type, extract[j].type) == 0)
+ {
+ extract_idx = j;
+ break;
+ }
+ }
+ if (extract_idx < 0)
+ return -1;
+
+ num_layers = extract[extract_idx].num_images;
+
+ /* Sanity checks */
+ src_buffer = gimp_drawable_get_buffer (drawable_ID);
+ precision = gimp_image_get_precision (image_ID);
+
+ for (j = 0; j < num_layers; j++)
+ {
+ /* FIXME: Not 100% reliable */
+ decomp_has_alpha |= ! g_strcmp0 ("alpha", extract[extract_idx].component[j].babl_name);
+ decomp_has_alpha |= ! g_strcmp0 ("A", extract[extract_idx].component[j].babl_name);
+ }
+
+ requirements |= (gimp_drawable_is_rgb (drawable_ID));
+ requirements |= (gimp_drawable_is_indexed (drawable_ID));
+ requirements |= (gimp_drawable_is_gray (drawable_ID)
+ && gimp_drawable_has_alpha (drawable_ID)
+ && (num_layers <= 2)
+ && decomp_has_alpha);
+ requirements &= (!decomp_has_alpha || gimp_drawable_has_alpha (drawable_ID));
+
+ if (!requirements)
+ {
+ g_message (_("Image not suitable for this decomposition"));
+ return -1;
+ }
+
+ width = gegl_buffer_get_width (src_buffer);
+ height = gegl_buffer_get_height (src_buffer);
+
+ /* Create all new gray images */
+ for (j = 0; j < num_layers; j++)
+ {
+ gchar *filename;
+ gdouble xres, yres;
+
+ filename = generate_filename (image_ID, extract_idx, j);
+ gimp_image_get_resolution (image_ID, &xres, &yres);
+
+ if (decovals.as_layers)
+ {
+ layername = gettext (extract[extract_idx].component[j].channel_name);
+
+ if (j == 0)
+ image_ID_dst[j] = create_new_image (filename, layername,
+ width, height, GIMP_GRAY, precision,
+ xres, yres,
+ layer_ID_dst + j);
+ else
+ layer_ID_dst[j] = create_new_layer (image_ID_dst[0], j, layername,
+ width, height, GIMP_GRAY);
+ }
+ else
+ {
+ image_ID_dst[j] = create_new_image (filename, NULL,
+ width, height, GIMP_GRAY, precision,
+ xres, yres,
+ layer_ID_dst + j);
+ }
+
+ g_free (filename);
+
+ dst_buffer[j] = gimp_drawable_get_buffer (layer_ID_dst[j]);
+ }
+
+ copy_n_components (src_buffer, dst_buffer,
+ extract[extract_idx]);
+
+ if (decovals.use_registration)
+ transfer_registration_color (src_buffer, dst_buffer, num_layers);
+
+ gimp_progress_update (1.0);
+
+ g_object_unref (src_buffer);
+
+ for (j = 0; j < num_layers; j++)
+ {
+ g_object_unref (dst_buffer[j]);
+ }
+
+ *nlayers = num_layers;
+
+ return (decovals.as_layers ? 1 : num_layers);
+}
+
+
+/* Create an image. Returns layer_ID and image_ID */
+static gint32
+create_new_image (const gchar *filename,
+ const gchar *layername,
+ guint width,
+ guint height,
+ GimpImageBaseType type,
+ GimpPrecision precision,
+ gdouble xres,
+ gdouble yres,
+ gint32 *layer_ID)
+{
+ gint32 image_ID;
+
+ image_ID = gimp_image_new_with_precision (width, height, type, precision);
+
+ gimp_image_undo_disable (image_ID);
+ gimp_image_set_filename (image_ID, filename);
+ gimp_image_set_resolution (image_ID, xres, yres);
+
+ *layer_ID = create_new_layer (image_ID, 0,
+ layername, width, height, type);
+
+ return image_ID;
+}
+
+
+static gint32
+create_new_layer (gint32 image_ID,
+ gint position,
+ const gchar *layername,
+ guint width,
+ guint height,
+ GimpImageBaseType type)
+{
+ gint32 layer_ID;
+ GimpImageType gdtype = GIMP_RGB_IMAGE;
+
+ switch (type)
+ {
+ case GIMP_RGB:
+ gdtype = GIMP_RGB_IMAGE;
+ break;
+ case GIMP_GRAY:
+ gdtype = GIMP_GRAY_IMAGE;
+ break;
+ case GIMP_INDEXED:
+ gdtype = GIMP_INDEXED_IMAGE;
+ break;
+ }
+
+ if (! layername)
+ layername = _("Background");
+
+ layer_ID = gimp_layer_new (image_ID, layername, width, height,
+ gdtype,
+ 100,
+ gimp_image_get_default_new_layer_mode (image_ID));
+ gimp_image_insert_layer (image_ID, layer_ID, -1, position);
+
+ return layer_ID;
+}
+
+/* Registration Color function */
+
+static void
+transfer_registration_color (GeglBuffer *src,
+ GeglBuffer **dst,
+ gint count)
+{
+ GimpRGB color, test;
+ GeglBufferIterator *gi;
+ const Babl *src_format;
+ const Babl *dst_format;
+ gint src_bpp;
+ gint dst_bpp;
+ gint i;
+ gdouble white;
+
+ gimp_context_get_foreground (&color);
+ white = 1.0;
+
+ src_format = gegl_buffer_get_format (src);
+ src_bpp = babl_format_get_bytes_per_pixel (src_format);
+
+ dst_format = gegl_buffer_get_format (dst[0]);
+ dst_bpp = babl_format_get_bytes_per_pixel (dst_format);
+
+ gi = gegl_buffer_iterator_new (src, NULL, 0, NULL,
+ GEGL_ACCESS_READ, GEGL_ABYSS_NONE, 10);
+
+ for (i = 0; i < count; i++)
+ {
+ gegl_buffer_iterator_add (gi, dst[i], NULL, 0, NULL,
+ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE);
+ }
+
+ while (gegl_buffer_iterator_next (gi))
+ {
+ gpointer src_data;
+ gpointer dst_data[MAX_EXTRACT_IMAGES];
+ gint j, k;
+
+ src_data = gi->items[0].data;
+ for (j = 0; j < count; j++)
+ dst_data[j] = gi->items[j + 1].data;
+
+ for (k = 0; k < gi->length; k++)
+ {
+ gulong pos = k * src_bpp;
+
+ gimp_rgba_set_pixel (&test, src_format, ((guchar *)src_data) + pos);
+
+ if (gimp_rgb_distance (&test, &color) < 1e-6)
+ {
+ for (j = 0; j < count; j++)
+ {
+ gpointer data = dst_data[j];
+
+ babl_process (babl_fish (babl_format ("Y double"), dst_format),
+ &white, (guchar *)data + (k * dst_bpp), 1);
+ }
+ }
+ }
+ }
+}
+
+static void
+cpn_affine_transform_clamp (GeglBuffer *buffer,
+ gdouble min,
+ gdouble max,
+ gboolean clamp)
+{
+ GeglBufferIterator *gi;
+ gdouble scale = 1.0 / (max - min);
+ gdouble offset = - min;
+
+ /* We want to scale values linearly, regardless of the format of the buffer */
+ gegl_buffer_set_format (buffer, babl_format ("Y double"));
+
+ gi = gegl_buffer_iterator_new (buffer, NULL, 0, NULL,
+ GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE, 1);
+
+ while (gegl_buffer_iterator_next (gi))
+ {
+ guint k;
+ double *data;
+
+ data = (double*) gi->items[0].data;
+
+ if (clamp)
+ {
+ for (k = 0; k < gi->length; k++)
+ {
+ data[k] = CLAMP ((data[k] + offset) * scale, 0.0, 1.0);
+ }
+ }
+ else
+ {
+ for (k = 0; k < gi->length; k++)
+ {
+ data[k] = (data[k] + offset) * scale;
+ }
+ }
+ }
+}
+
+static void
+copy_n_components (GeglBuffer *src,
+ GeglBuffer **dst,
+ Extract ext)
+{
+ gint i;
+
+ for (i = 0; i < ext.num_images; i++)
+ {
+ gimp_progress_update ((gdouble) i / (gdouble) ext.num_images);
+
+ copy_one_component (src, dst[i], ext.model, ext.component[i], ext.clamp);
+ }
+}
+
+static void
+copy_one_component (GeglBuffer *src,
+ GeglBuffer *dst,
+ const gchar *model,
+ const Component component,
+ gboolean clamp)
+{
+ const Babl *component_format;
+ const Babl *dst_format;
+ GeglBuffer *temp;
+ const GeglRectangle *extent;
+
+ /* We are working in linear double precision */
+ component_format = babl_format_new (babl_model (model),
+ babl_type ("double"),
+ babl_component (component.babl_name),
+ NULL);
+
+ /* We need to enforce linearity here
+ * If the output is "Y'", the output of temp is already ok
+ * If the output is "Y" , it will enforce gamma-decoding.
+ * A bit tricky and suboptimal...
+ */
+ if (component.perceptual_channel)
+ dst_format = babl_format ("Y' double");
+ else
+ dst_format = babl_format ("Y double");
+
+ extent = gegl_buffer_get_extent (src);
+ temp = gegl_buffer_new (extent, dst_format);
+
+ /* we want to copy the component as is */
+ gegl_buffer_set_format (temp, component_format);
+ gegl_buffer_copy (src, NULL, GEGL_ABYSS_NONE, temp, NULL);
+
+ if (component.range_min != 0.0 ||
+ component.range_max != 1.0 ||
+ clamp)
+ {
+ cpn_affine_transform_clamp (temp,
+ component.range_min, component.range_max,
+ clamp);
+ }
+
+ /* This is our new "Y(') double" component buffer */
+ gegl_buffer_set_format (temp, NULL);
+
+ /* Now we let babl convert it back to the format that dst needs */
+ gegl_buffer_copy (temp, NULL, GEGL_ABYSS_NONE, dst, NULL);
+
+ g_object_unref (temp);
+}
+
+static gboolean
+decompose_dialog (void)
+{
+ GtkWidget *dialog;
+ GtkWidget *main_vbox;
+ GtkWidget *frame;
+ GtkWidget *vbox;
+ GtkWidget *hbox;
+ GtkWidget *label;
+ GtkWidget *combo;
+ GtkWidget *toggle;
+ gint j;
+ gint extract_idx;
+ gboolean run;
+
+ extract_idx = 0;
+ for (j = 0; j < G_N_ELEMENTS (extract); j++)
+ {
+ if (extract[j].dialog &&
+ g_ascii_strcasecmp (decovals.extract_type, extract[j].type) == 0)
+ {
+ extract_idx = j;
+ break;
+ }
+ }
+
+ gimp_ui_init (PLUG_IN_BINARY, FALSE);
+
+ dialog = gimp_dialog_new (_("Decompose"), PLUG_IN_ROLE,
+ NULL, 0,
+ gimp_standard_help_func, PLUG_IN_PROC,
+
+ _("_Cancel"), GTK_RESPONSE_CANCEL,
+ _("_OK"), GTK_RESPONSE_OK,
+
+ NULL);
+
+ gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
+ GTK_RESPONSE_OK,
+ GTK_RESPONSE_CANCEL,
+ -1);
+
+ gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
+ gimp_window_set_transient (GTK_WINDOW (dialog));
+
+ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
+ gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
+ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
+ main_vbox, TRUE, TRUE, 0);
+ gtk_widget_show (main_vbox);
+
+ frame = gimp_frame_new (_("Extract Channels"));
+ gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
+ gtk_widget_show (frame);
+
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+ gtk_container_add (GTK_CONTAINER (frame), vbox);
+ gtk_widget_show (vbox);
+
+ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+ gtk_widget_show (hbox);
+
+ label = gtk_label_new_with_mnemonic (_("Color _model:"));
+ gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+ gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
+ gtk_widget_show (label);
+
+ combo = g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL);
+ for (j = 0; j < G_N_ELEMENTS (extract); j++)
+ {
+ if (extract[j].dialog)
+ {
+ gchar *label = g_strdup (gettext (extract[j].type));
+ gchar *l;
+
+ for (l = label; *l; l++)
+ if (*l == '-' || *l == '_')
+ *l = ' ';
+
+ gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (combo),
+ GIMP_INT_STORE_LABEL, label,
+ GIMP_INT_STORE_VALUE, j,
+ -1);
+ g_free (label);
+ }
+ }
+
+ gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0);
+ gtk_widget_show (combo);
+
+ gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
+
+ gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo),
+ extract_idx,
+ G_CALLBACK (gimp_int_combo_box_get_active),
+ &extract_idx);
+
+ toggle = gtk_check_button_new_with_mnemonic (_("_Decompose to layers"));
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
+ decovals.as_layers);
+ gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0);
+ gtk_widget_show (toggle);
+
+ g_signal_connect (toggle, "toggled",
+ G_CALLBACK (gimp_toggle_button_update),
+ &decovals.as_layers);
+
+ toggle =
+ gtk_check_button_new_with_mnemonic (_("_Foreground as registration color"));
+ gimp_help_set_help_data (toggle, _("Pixels in the foreground color will "
+ "appear black in all output images. "
+ "This can be used for things like crop "
+ "marks that have to show up on all "
+ "channels."), PLUG_IN_PROC);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
+ decovals.use_registration);
+ gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0);
+ gtk_widget_show (toggle);
+
+ g_signal_connect (toggle, "toggled",
+ G_CALLBACK (gimp_toggle_button_update),
+ &decovals.use_registration);
+
+ gtk_widget_show (dialog);
+
+ run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
+
+ gtk_widget_destroy (dialog);
+
+ if (run)
+ strncpy (decovals.extract_type, extract[extract_idx].type,
+ sizeof decovals.extract_type - 1);
+
+ return run;
+}
+
+/* Build a filename like <imagename>-<channel>.<extension> */
+gchar *
+generate_filename (guint32 image_ID,
+ guint colorspace,
+ guint channel)
+{
+ /* Build a filename like <imagename>-<channel>.<extension> */
+ gchar *fname;
+ gchar *filename;
+ gchar *extension;
+
+ fname = gimp_image_get_filename (image_ID);
+
+ if (fname)
+ {
+ extension = fname + strlen (fname) - 1;
+
+ while (extension >= fname)
+ {
+ if (*extension == '.')
+ break;
+ extension--;
+ }
+
+ if (extension >= fname)
+ {
+ *(extension++) = '\0';
+
+ if (decovals.as_layers)
+ filename = g_strdup_printf ("%s-%s.%s", fname,
+ gettext (extract[colorspace].type),
+ extension);
+ else
+ filename = g_strdup_printf ("%s-%s.%s", fname,
+ gettext (extract[colorspace].component[channel].channel_name),
+ extension);
+ }
+ else
+ {
+ if (decovals.as_layers)
+ filename = g_strdup_printf ("%s-%s", fname,
+ gettext (extract[colorspace].type));
+ else
+ filename = g_strdup_printf ("%s-%s", fname,
+ gettext (extract[colorspace].component[channel].channel_name));
+ }
+ }
+ else
+ {
+ filename = g_strdup (gettext (extract[colorspace].component[channel].channel_name));
+ }
+
+ g_free (fname);
+
+ return filename;
+}