dallasgroot/Gimp
dallasgroot/Gimp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Gimp/plug-ins/common/decompose.c
Michael Natterer b10adabb5e Added parent window API to the GimpProgress interface and to the libgimp 
2005-09-09  Michael Natterer  <mitch@gimp.org>

	Added parent window API to the GimpProgress interface and to
	the libgimp progress stuff. Might look strange, but does
	the right thing in almost all cases (image window, file dialog,
	script-fu dialog etc). Fixes bug #62988.

	* app/core/gimpprogress.[ch]: added GimpProgress::get_window()
	which should return a toplevel window ID if the progress is in a
	window that wants to be the transient parent of plug-in dialogs.

	* app/widgets/gimpwidgets-utils.[ch] (gimp_window_get_native): new
	function which returns the window handle of a GtkWindow's GdkWindow.

	* app/widgets/gimpfiledialog.c: implement ::get_window().

	* app/display/gimpdisplay.[ch]: ditto. Removed window handle API.

	* app/gui/gui-vtable.c: changed accordingly.

	* libgimpbase/gimpbaseenums.[ch] (enum GimpProgressCommand):
	added GIMP_PROGRESS_COMMAND_GET_WINDOW.

	* app/plug-in/plug-in-progress.[ch] (plug_in_progress_get_window):
	new function. Also renamed some functions to match the
	GimpProgress interface, and not the legacy PDB procedure names.

	* tools/pdbgen/pdb/progress.pdb
	* app/core/gimppdbprogress.c: implement get_window() on both
	sides of the wire, keeping backward compatibility (hopefully).

	* libgimp/gimpprogress.[ch]: deprecated gimp_progress_install()
	and added gimp_progress_install_vtable() which takes a vtable with
	padding to be extensible. Added get_window() vtable entry and
	dispatch it accordingly. Also added pulse() which was implemented
	in a hackish way before. Everything is of course backward
	compatible.

	* libgimp/gimpprogressbar.c: inmplement the get_window() stuff
	so a plug-in dialog containing a progress can be the transient
	parent of another dialog in another plug-in.

	* libgimp/gimpui.[ch] (gimp_ui_get_progress_window): new function
	which returns a foreign GdkWindow of this plug-ins progress
	window.

	Renamed gimp_window_set_transient_for_default_display() to
	gimp_window_set_transient() and make it use the progress' window
	handle instead of the display's (which is the right thing to do in
	almost all cases).

	* libgimp/gimp.def
	* libgimp/gimpui.def: add the new functions.

	* tools/pdbgen/enums.pl
	* app/pdb/internal_procs.c
	* app/pdb/progress_cmds.c
	* libgimp/gimpprogress_pdb.[ch]: regenerated.

	* libgimp/gimpexport.c
	* plug-ins/*/*.c: follow API change.
2005-09-09 18:07:31 +00:00

1310 lines
37 KiB
C
Raw Blame History

/* The GIMP -- an 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
*
* 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 2 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*
* This filter decomposes RGB-images into several types of channels
*/
/* 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"
/* cbrt() is a GNU extension, which C99 accepted */
#if !defined (__GLIBC__) && !(defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L)
#define cbrt(x) (pow(x, 1.0/3.0))
#endif
#define PLUG_IN_PROC "plug-in-decompose"
#define PLUG_IN_BINARY "decompose"
/* 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,
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,
gdouble xres,
gdouble yres,
gint32 *layer_ID,
GimpDrawable **drawable,
GimpPixelRgn *pixel_rgn);
static gint32 create_new_layer (gint32 image_ID,
const gchar *layername,
guint width,
guint height,
GimpImageBaseType type,
GimpDrawable **drawable,
GimpPixelRgn *pixel_rgn);
static void extract_rgb (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_red (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_green (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_blue (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_rgba (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_alpha (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_hsv (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_hue (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_sat (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_val (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_cmy (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_cyan (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_magenta (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_yellow (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_cmyk (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_cyank (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_magentak (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_yellowk (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_lab (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_ycbcr470 (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_ycbcr709 (guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_ycbcr470f(guchar *src, gint bpp, gint numpix, guchar **dst);
static void extract_ycbcr709f(guchar *src, gint bpp, gint numpix, guchar **dst);
static gboolean decompose_dialog (void);
/* LAB colorspace constants */
static const gdouble Xn = 0.951;
static const gdouble Yn = 1.0;
static const gdouble Zn = 1.089;
/* Maximum number of new images generated by an extraction */
#define MAX_EXTRACT_IMAGES 4
/* Description of an extraction */
typedef struct
{
gchar *type; /* What to extract */
gint dialog; /* Dialog-Flag. Set it to 1 if you want to appear */
/* this extract function within the dialog */
gint num_images; /* Number of images to create */
gchar *channel_name[MAX_EXTRACT_IMAGES]; /* Names of channels to extract */
/* Function that performs the extraction */
void (*extract_fun) (guchar *src, int bpp, gint numpix, guchar **dst);
} EXTRACT;
static EXTRACT extract[] =
{
{ N_("RGB"), TRUE, 3, { N_("red"),
N_("green"),
N_("blue") }, extract_rgb },
{ N_("Red"), FALSE, 1, { N_("red") }, extract_red },
{ N_("Green"), FALSE, 1, { N_("green") }, extract_green },
{ N_("RGBA"), TRUE, 4, { N_("red"),
N_("green"),
N_("blue"),
N_("alpha") }, extract_rgba },
{ N_("Blue"), FALSE, 1, { N_("blue") }, extract_blue },
{ N_("HSV"), TRUE, 3, { N_("hue"),
N_("saturation"),
N_("value") }, extract_hsv },
{ N_("Hue"), FALSE, 1, { N_("hue") }, extract_hue },
{ N_("Saturation"), FALSE, 1, { N_("saturation") }, extract_sat },
{ N_("Value"), FALSE, 1, { N_("value") }, extract_val },
{ N_("CMY"), TRUE, 3, { N_("cyan"),
N_("magenta"),
N_("yellow") }, extract_cmy },
{ N_("Cyan"), FALSE, 1, { N_("cyan") }, extract_cyan },
{ N_("Magenta"), FALSE, 1, { N_("magenta") }, extract_magenta },
{ N_("Yellow"), FALSE, 1, { N_("yellow") }, extract_yellow },
{ N_("CMYK"), TRUE, 4, { N_("cyan_k"),
N_("magenta_k"),
N_("yellow_k"),
N_("black") }, extract_cmyk },
{ N_("Cyan_K"), FALSE, 1, { N_("cyan_k") }, extract_cyank },
{ N_("Magenta_K"), FALSE, 1, { N_("magenta_k") }, extract_magentak },
{ N_("Yellow_K"), FALSE, 1, { N_("yellow_k") }, extract_yellowk },
{ N_("Alpha"), TRUE, 1, { N_("alpha") }, extract_alpha },
{ N_("LAB"), TRUE, 3, { "L",
"A",
"B" }, extract_lab },
{ "YCbCr_ITU_R470",
TRUE, 3, { N_("luma_y470"),
N_("blueness_cb470"),
N_("redness_cr470") }, extract_ycbcr470 },
{ "YCbCr_ITU_R709",
TRUE, 3, { N_("luma_y709"),
N_("blueness_cb709"),
N_("redness_cr709") }, extract_ycbcr709 },
{ "YCbCr_ITU_R470_256",
TRUE, 3, { N_("luma_y470f"),
N_("blueness_cb470f"),
N_("redness_cr470f") }, extract_ycbcr470f },
{ "YCbCr_ITU_R709_256",
TRUE, 3, { N_("luma_y709f"),
N_("blueness_cb709f"),
N_("redness_cr709f") }, extract_ycbcr709f },
};
typedef struct
{
gchar extract_type[32];
gboolean as_layers;
} DecoVals;
typedef struct
{
gint extract_flag[G_N_ELEMENTS (extract)];
} DecoInterface;
GimpPlugInInfo PLUG_IN_INFO =
{
NULL, /* init_proc */
NULL, /* quit_proc */
query, /* query_proc */
run, /* run_proc */
};
static DecoVals decovals =
{
"rgb", /* Decompose type */
TRUE /* Decompose to Layers */
};
static DecoInterface decoint =
{
{ 0 } /* extract flags */
};
static GimpRunMode run_mode;
MAIN ()
static void
query (void)
{
static GimpParamDef args[] =
{
{ GIMP_PDB_INT32, "run-mode", "Interactive, non-interactive" },
{ GIMP_PDB_IMAGE, "image", "Input image (unused)" },
{ GIMP_PDB_DRAWABLE, "drawable", "Input drawable" },
{ GIMP_PDB_STRING, "decompose-type", "What to decompose: RGB, Red, Green, Blue, RGBA, Red, Green, Blue, Alpha, HSV, Hue, Saturation, Value, CMY, Cyan, Magenta, Yellow, CMYK, Cyan_K, Magenta_K, Yellow_K, Alpha, LAB" },
{ GIMP_PDB_INT32, "layers-mode", "Create channels as layers in a single image" }
};
static 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)" }
};
gimp_install_procedure (PLUG_IN_PROC,
"Decompose an image into different types of channels",
"This function creates new gray images with "
"different channel information in each of them",
"Peter Kirchgessner",
"Peter Kirchgessner (peter@kirchgessner.net)",
"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, "<Image>/Colors/Components");
}
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;
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 ();
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)
{
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;
}
break;
case GIMP_RUN_WITH_LAST_VALS:
/* Possibly retrieve data */
gimp_get_data (PLUG_IN_PROC, &decovals);
break;
default:
break;
}
/* Make sure that the drawable is RGB color */
if (gimp_drawable_type_with_alpha (layer) != GIMP_RGBA_IMAGE)
{
g_message ("Can only work on RGB images.");
status = GIMP_PDB_CALLING_ERROR;
}
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++)
{
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]);
gimp_image_attach_new_parasite (image_ID_extract[j],
"decompose-data",
0, data->len + 1, data->str);
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 (DecoVals));
}
}
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,
char *extract_type,
gint32 *image_ID_dst,
gint32 *nlayers,
gint32 *layer_ID_dst)
{
const gchar *layername;
gint i, j, extract_idx, scan_lines;
gint height, width, tile_height, num_layers;
gchar *filename;
guchar *src;
guchar *dst[MAX_EXTRACT_IMAGES];
GimpDrawable *drawable_src;
GimpDrawable *drawable_dst[MAX_EXTRACT_IMAGES];
GimpPixelRgn pixel_rgn_src;
GimpPixelRgn pixel_rgn_dst[MAX_EXTRACT_IMAGES];
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;
/* Check structure of source image */
drawable_src = gimp_drawable_get (drawable_ID);
if (drawable_src->bpp < 3)
{
g_message ("Not an RGB image.");
return -1;
}
if ((extract[extract_idx].extract_fun == extract_alpha ||
extract[extract_idx].extract_fun == extract_rgba) &&
(!gimp_drawable_has_alpha (drawable_ID)))
{
g_message ("No alpha channel available.");
return -1;
}
width = drawable_src->width;
height = drawable_src->height;
tile_height = gimp_tile_height ();
gimp_pixel_rgn_init (&pixel_rgn_src, drawable_src, 0, 0, width, height,
FALSE, FALSE);
/* allocate a buffer for retrieving information from the src pixel region */
src = g_new (guchar, tile_height * width * drawable_src->bpp);
/* Create all new gray images */
num_layers = extract[extract_idx].num_images;
if (num_layers > MAX_EXTRACT_IMAGES)
num_layers = MAX_EXTRACT_IMAGES;
for (j = 0; j < num_layers; j++)
{
/* Build a filename like <imagename>-<channel>.<extension> */
gchar *fname;
gchar *extension;
gdouble xres, yres;
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[extract_idx].type),
extension);
else
filename = g_strdup_printf ("%s-%s.%s", fname,
gettext (extract[extract_idx].channel_name[j]),
extension);
}
else
{
if (decovals.as_layers)
filename = g_strdup_printf ("%s-%s", fname,
gettext (extract[extract_idx].type));
else
filename = g_strdup_printf ("%s-%s", fname,
gettext (extract[extract_idx].channel_name[j]));
}
}
else
{
filename = g_strdup (gettext (extract[extract_idx].channel_name[j]));
}
gimp_image_get_resolution (image_ID, &xres, &yres);
if (decovals.as_layers)
{
layername = gettext (extract[extract_idx].channel_name[j]);
if (j == 0)
image_ID_dst[j] = create_new_image (filename, layername,
width, height, GIMP_GRAY,
xres, yres,
layer_ID_dst + j,
drawable_dst + j,
pixel_rgn_dst + j);
else
layer_ID_dst[j] = create_new_layer (image_ID_dst[0], layername,
width, height, GIMP_GRAY,
drawable_dst + j,
pixel_rgn_dst + j);
}
else
{
image_ID_dst[j] = create_new_image (filename, NULL,
width, height, GIMP_GRAY,
xres, yres,
layer_ID_dst + j,
drawable_dst + j,
pixel_rgn_dst + j);
}
g_free (filename);
g_free (fname);
dst[j] = g_new (guchar, tile_height * width);
}
i = 0;
while (i < height)
{
/* Get source pixel region */
scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i);
gimp_pixel_rgn_get_rect (&pixel_rgn_src, src, 0, i, width, scan_lines);
/* Extract the channel information */
extract[extract_idx].extract_fun (src, drawable_src->bpp, scan_lines*width,
dst);
/* Set destination pixel regions */
for (j = 0; j < num_layers; j++)
gimp_pixel_rgn_set_rect (&(pixel_rgn_dst[j]), dst[j], 0, i, width,
scan_lines);
i += scan_lines;
gimp_progress_update ((gdouble) i / (gdouble) height);
}
g_free (src);
for (j = 0; j < num_layers; j++)
{
gimp_drawable_detach (drawable_dst[j]);
gimp_drawable_update (layer_ID_dst[j], 0, 0,
gimp_drawable_width (layer_ID_dst[j]),
gimp_drawable_height (layer_ID_dst[j]));
gimp_layer_add_alpha (layer_ID_dst[j]);
g_free (dst[j]);
}
gimp_drawable_detach (drawable_src);
*nlayers = num_layers;
return (decovals.as_layers ? 1 : num_layers);
}
/* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */
static gint32
create_new_image (const gchar *filename,
const gchar *layername,
guint width,
guint height,
GimpImageBaseType type,
gdouble xres,
gdouble yres,
gint32 *layer_ID,
GimpDrawable **drawable,
GimpPixelRgn *pixel_rgn)
{
gint32 image_ID;
image_ID = gimp_image_new (width, height, type);
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,
layername, width, height, type,
drawable, pixel_rgn);
return image_ID;
}
static gint32
create_new_layer (gint32 image_ID,
const gchar *layername,
guint width,
guint height,
GimpImageBaseType type,
GimpDrawable **drawable,
GimpPixelRgn *pixel_rgn)
{
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_NORMAL_MODE);
gimp_image_add_layer (image_ID, layer_ID, 0);
*drawable = gimp_drawable_get (layer_ID);
gimp_pixel_rgn_init (pixel_rgn, *drawable, 0, 0, (*drawable)->width,
(*drawable)->height, TRUE, FALSE);
return layer_ID;
}
/* Extract functions */
static void
extract_rgb (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *red_dst = dst[0];
register guchar *green_dst = dst[1];
register guchar *blue_dst = dst[2];
register gint count = numpix, offset = bpp-3;
while (count-- > 0)
{
*(red_dst++) = *(rgb_src++);
*(green_dst++) = *(rgb_src++);
*(blue_dst++) = *(rgb_src++);
rgb_src += offset;
}
}
static void
extract_rgba (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgba_src = src;
register guchar *red_dst = dst[0];
register guchar *green_dst = dst[1];
register guchar *blue_dst = dst[2];
register guchar *alpha_dst = dst[3];
register gint count = numpix, offset = bpp-4;
while (count-- > 0)
{
*(red_dst++) = *(rgba_src++);
*(green_dst++) = *(rgba_src++);
*(blue_dst++) = *(rgba_src++);
*(alpha_dst++) = *(rgba_src++);
rgba_src += offset;
}
}
static void
extract_red (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *red_dst = dst[0];
register gint count = numpix, offset = bpp;
while (count-- > 0)
{
*(red_dst++) = *rgb_src;
rgb_src += offset;
}
}
static void
extract_green (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src+1;
register guchar *green_dst = dst[0];
register gint count = numpix, offset = bpp;
while (count-- > 0)
{
*(green_dst++) = *rgb_src;
rgb_src += offset;
}
}
static void
extract_blue (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src+2;
register guchar *blue_dst = dst[0];
register gint count = numpix, offset = bpp;
while (count-- > 0)
{
*(blue_dst++) = *rgb_src;
rgb_src += offset;
}
}
static void
extract_alpha (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src+3;
register guchar *alpha_dst = dst[0];
register gint count = numpix, offset = bpp;
while (count-- > 0)
{
*(alpha_dst++) = *rgb_src;
rgb_src += offset;
}
}
static void
extract_cmy (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *cyan_dst = dst[0];
register guchar *magenta_dst = dst[1];
register guchar *yellow_dst = dst[2];
register gint count = numpix, offset = bpp-3;
while (count-- > 0)
{
*(cyan_dst++) = 255 - *(rgb_src++);
*(magenta_dst++) = 255 - *(rgb_src++);
*(yellow_dst++) = 255 - *(rgb_src++);
rgb_src += offset;
}
}
static void
extract_hsv (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *hue_dst = dst[0];
register guchar *sat_dst = dst[1];
register guchar *val_dst = dst[2];
register gint count = numpix, offset = bpp;
gdouble hue, sat, val;
while (count-- > 0)
{
gimp_rgb_to_hsv4 (rgb_src, &hue, &sat, &val);
*hue_dst++ = (guchar) (hue * 255.999);
*sat_dst++ = (guchar) (sat * 255.999);
*val_dst++ = (guchar) (val * 255.999);
rgb_src += offset;
}
}
static void
extract_hue (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *hue_dst = dst[0];
register gint count = numpix, offset = bpp;
gdouble hue, dummy;
while (count-- > 0)
{
gimp_rgb_to_hsv4 (rgb_src, &hue, &dummy, &dummy);
*hue_dst++ = (guchar) (hue * 255.999);
rgb_src += offset;
}
}
static void
extract_sat (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *sat_dst = dst[0];
register gint count = numpix, offset = bpp;
gdouble sat, dummy;
while (count-- > 0)
{
gimp_rgb_to_hsv4 (rgb_src, &dummy, &sat, &dummy);
*sat_dst++ = (guchar) (sat * 255.999);
rgb_src += offset;
}
}
static void
extract_val (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *val_dst = dst[0];
register gint count = numpix, offset = bpp;
gdouble val, dummy;
while (count-- > 0)
{
gimp_rgb_to_hsv4 (rgb_src, &dummy, &dummy, &val);
*val_dst++ = (guchar) (val * 255.999);
rgb_src += offset;
}
}
static void
extract_cyan (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *cyan_dst = dst[0];
register gint count = numpix, offset = bpp-1;
while (count-- > 0)
{
*(cyan_dst++) = 255 - *(rgb_src++);
rgb_src += offset;
}
}
static void
extract_magenta (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src+1;
register guchar *magenta_dst = dst[0];
register gint count = numpix, offset = bpp-1;
while (count-- > 0)
{
*(magenta_dst++) = 255 - *(rgb_src++);
rgb_src += offset;
}
}
static void
extract_yellow (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src+2;
register guchar *yellow_dst = dst[0];
register gint count = numpix, offset = bpp-1;
while (count-- > 0)
{
*(yellow_dst++) = 255 - *(rgb_src++);
rgb_src += offset;
}
}
static void
extract_cmyk (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *cyan_dst = dst[0];
register guchar *magenta_dst = dst[1];
register guchar *yellow_dst = dst[2];
register guchar *black_dst = dst[3];
register guchar k, s;
register gint count = numpix, offset = bpp-3;
while (count-- > 0)
{
*cyan_dst = k = 255 - *(rgb_src++);
*magenta_dst = s = 255 - *(rgb_src++);
if (s < k)
k = s;
*yellow_dst = s = 255 - *(rgb_src++);
if (s < k)
k = s; /* Black intensity is minimum of c, m, y */
if (k)
{
*cyan_dst -= k; /* Remove common part of c, m, y */
*magenta_dst -= k;
*yellow_dst -= k;
}
cyan_dst++;
magenta_dst++;
yellow_dst++;
*(black_dst++) = k;
rgb_src += offset;
}
}
static void
extract_cyank (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *cyan_dst = dst[0];
register guchar s, k;
register gint count = numpix, offset = bpp-3;
while (count-- > 0)
{
*cyan_dst = k = 255 - *(rgb_src++);
s = 255 - *(rgb_src++); /* magenta */
if (s < k) k = s;
s = 255 - *(rgb_src++); /* yellow */
if (s < k) k = s;
if (k) *cyan_dst -= k;
cyan_dst++;
rgb_src += offset;
}
}
static void
extract_magentak (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *magenta_dst = dst[0];
register guchar s, k;
register gint count = numpix, offset = bpp-3;
while (count-- > 0)
{
k = 255 - *(rgb_src++); /* cyan */
*magenta_dst = s = 255 - *(rgb_src++); /* magenta */
if (s < k)
k = s;
s = 255 - *(rgb_src++); /* yellow */
if (s < k)
k = s;
if (k)
*magenta_dst -= k;
magenta_dst++;
rgb_src += offset;
}
}
static void
extract_yellowk (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *yellow_dst = dst[0];
register guchar s, k;
register gint count = numpix, offset = bpp-3;
while (count-- > 0)
{
k = 255 - *(rgb_src++); /* cyan */
s = 255 - *(rgb_src++); /* magenta */
if (s < k) k = s;
*yellow_dst = s = 255 - *(rgb_src++);
if (s < k)
k = s;
if (k)
*yellow_dst -= k;
yellow_dst++;
rgb_src += offset;
}
}
static void
extract_lab (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *l_dst = dst[0];
register guchar *a_dst = dst[1];
register guchar *b_dst = dst[2];
register gint count = numpix, offset = bpp;
gdouble red, green, blue;
gdouble x, y, z;
gdouble l; /*, a, b; */
gdouble tx, ty, tz;
gdouble ftx, fty, ftz;
gdouble sixteenth = 16.0 / 116.0;
while (count-- > 0)
{
red = rgb_src[0] / 255.0;
green = rgb_src[1] / 255.0;
blue = rgb_src[2] / 255.0;
x = 0.431 * red + 0.342 * green + 0.178 * blue;
y = 0.222 * red + 0.707 * green + 0.071 * blue;
z = 0.020 * red + 0.130 * green + 0.939 * blue;
if (( ty = y/Yn ) > 0.008856)
{
l = 116.0 * cbrt( ty ) - 16.0;
fty = cbrt( ty );
}
else
{
l = 903.3 * ty;
fty = 7.78*ty + sixteenth;
}
ftx = ((tx = x/Xn) > 0.008856) ? cbrt (tx) : 7.78 * tx + sixteenth;
ftz = ((tz = z/Zn) > 0.008856) ? cbrt (tz) : 7.78 * tz + sixteenth;
*l_dst++ = (guchar) CLAMP (l * 2.5599, 0., 256.);
*a_dst++ = (guchar) CLAMP (128.0 + (ftx - fty) * 635, 0., 256.);
*b_dst++ = (guchar) CLAMP (128.0 + (fty - ftz) * 254, 0., 256.);
rgb_src += offset;
}
}
/* these are here so the code is more readable and we can use
the standard values instead of some scaled and rounded fixpoint values */
#define FIX(a) ((int)((a)*256.0*256.0 + 0.5))
#define FIXY(a) ((int)((a)*256.0*256.0*219.0/255.0 + 0.5))
#define FIXC(a) ((int)((a)*256.0*256.0*224.0/255.0 + 0.5))
static void
extract_ycbcr470 (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *y_dst = dst[0];
register guchar *cb_dst = dst[1];
register guchar *cr_dst = dst[2];
register gint count = numpix, offset = bpp-3;
while (count-- > 0)
{
register int r, g, b;
r= *(rgb_src++);
g= *(rgb_src++);
b= *(rgb_src++);
*(y_dst++) = ( FIXY(0.2989)*r + FIXY(0.5866)*g + FIXY(0.1145)*b + FIX( 16.5))>>16;
*(cb_dst++) = (-FIXC(0.1688)*r - FIXC(0.3312)*g + FIXC(0.5000)*b + FIX(128.5))>>16;
*(cr_dst++) = ( FIXC(0.5000)*r - FIXC(0.4184)*g - FIXC(0.0816)*b + FIX(128.5))>>16;
rgb_src += offset;
}
}
static void
extract_ycbcr709 (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *y_dst = dst[0];
register guchar *cb_dst = dst[1];
register guchar *cr_dst = dst[2];
register gint count = numpix, offset = bpp-3;
while (count-- > 0)
{
register int r, g, b;
r= *(rgb_src++);
g= *(rgb_src++);
b= *(rgb_src++);
*(y_dst++) = ( FIXY(0.2126)*r + FIXY(0.7152)*g + FIXY(0.0722)*b + FIX( 16.5))>>16;
*(cb_dst++) = (-FIXC(0.1150)*r - FIXC(0.3860)*g + FIXC(0.5000)*b + FIX(128.5))>>16;
*(cr_dst++) = ( FIXC(0.5000)*r - FIXC(0.4540)*g - FIXC(0.0460)*b + FIX(128.5))>>16;
rgb_src += offset;
}
}
static void
extract_ycbcr470f (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *y_dst = dst[0];
register guchar *cb_dst = dst[1];
register guchar *cr_dst = dst[2];
register gint count = numpix, offset = bpp-3;
while (count-- > 0)
{
register int r, g, b, cb, cr;
r= *(rgb_src++);
g= *(rgb_src++);
b= *(rgb_src++);
*(y_dst++ ) = ( FIX(0.2989)*r + FIX(0.5866)*g + FIX(0.1145)*b + FIX( 0.5))>>16;
cb = (-FIX(0.1688)*r - FIX(0.3312)*g + FIX(0.5000)*b + FIX(128.5))>>16;
cr = ( FIX(0.5000)*r - FIX(0.4184)*g - FIX(0.0816)*b + FIX(128.5))>>16;
if(cb>255) cb=255;
if(cr>255) cr=255;
*(cb_dst++) = cb;
*(cr_dst++) = cr;
rgb_src += offset;
}
}
static void
extract_ycbcr709f (guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register guchar *rgb_src = src;
register guchar *y_dst = dst[0];
register guchar *cb_dst = dst[1];
register guchar *cr_dst = dst[2];
register gint count = numpix, offset = bpp-3;
while (count-- > 0)
{
register int r, g, b, cb, cr;
r= *(rgb_src++);
g= *(rgb_src++);
b= *(rgb_src++);
*(y_dst++) = ( FIX(0.2126)*r + FIX(0.7152)*g + FIX(0.0722)*b + FIX( 0.5))>>16;
cb = (-FIX(0.1150)*r - FIX(0.3860)*g + FIX(0.5000)*b + FIX(128.5))>>16;
cr = ( FIX(0.5000)*r - FIX(0.4540)*g - FIX(0.0460)*b + FIX(128.5))>>16;
if(cb>255) cb=255;
if(cr>255) cr=255;
*(cb_dst++) = cb;
*(cr_dst++) = cr;
rgb_src += offset;
}
}
static gboolean
decompose_dialog (void)
{
GtkWidget *dlg;
GtkWidget *main_vbox;
GtkWidget *toggle;
GtkWidget *frame;
GtkWidget *vbox;
GSList *group;
gint j;
gboolean run;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dlg = gimp_dialog_new (_("Decompose"), PLUG_IN_BINARY,
NULL, 0,
gimp_standard_help_func, PLUG_IN_PROC,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dlg));
main_vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), main_vbox,
TRUE, TRUE, 0);
gtk_widget_show (main_vbox);
/* parameter settings */
frame = gimp_frame_new (_("Extract Channels"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 0);
vbox = gtk_vbox_new (FALSE, 2);
gtk_container_add (GTK_CONTAINER (frame), vbox);
group = NULL;
for (j = 0; j < G_N_ELEMENTS (extract); j++)
{
if (!extract[j].dialog)
continue;
toggle = gtk_radio_button_new_with_label (group,
gettext (extract[j].type));
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (toggle));
gtk_box_pack_start (GTK_BOX (vbox), toggle, TRUE, TRUE, 0);
decoint.extract_flag[j] =
(g_ascii_strcasecmp (decovals.extract_type, extract[j].type) == 0);
gtk_widget_show (toggle);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&(decoint.extract_flag[j]));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
decoint.extract_flag[j]);
}
toggle = gtk_check_button_new_with_mnemonic (_("Decompose to _layers"));
gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0);
g_signal_connect (toggle, "toggled",
G_CALLBACK (gimp_toggle_button_update),
&decovals.as_layers);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle),
decovals.as_layers);
gtk_widget_show (toggle);
gtk_widget_show (vbox);
gtk_widget_show (frame);
gtk_widget_show (dlg);
run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK);
gtk_widget_destroy (dlg);
if (run)
{
gint j;
for (j = 0; j < G_N_ELEMENTS (extract); j++)
{
if (decoint.extract_flag[j])
{
strcpy (decovals.extract_type, extract[j].type);
break;
}
}
}
return run;
}
Reference in a new issue View git blame Copy permalink